Welcome To Our Shell

Mister Spy & Souheyl Bypass Shell

  
  70 Tables of Marks
  
  The  concept  of  a table of marks was introduced by W. Burnside in his book
  Theory of Groups of Finite Order, see [Bur55]. Therefore a table of marks is
  sometimes called a Burnside matrix.
  
  The  table  of  marks of a finite group G is a matrix whose rows and columns
  are  labelled  by  the conjugacy classes of subgroups of G and where for two
  subgroups A and B the (A, B)-entry is the number of fixed points of B in the
  transitive  action  of  G  on  the  cosets  of A in G. So the table of marks
  characterizes the set of all permutation representations of G.
  
  Moreover,  the  table  of  marks gives a compact description of the subgroup
  lattice  of  G,  since  from  the  numbers  of  fixed  points the numbers of
  conjugates of a subgroup B contained in a subgroup A can be derived.
  
  A  table  of  marks  of a given group G can be constructed from the subgroup
  lattice  of  G  (see 70.3).  For  several  groups, the table of marks can be
  restored from the GAP library of tables of marks (see 70.13).
  
  Given  the  table  of  marks  of G, one can display it (see 70.4) and derive
  information  about  G  and its Burnside ring from it (see 70.7, 70.8, 70.9).
  Moreover,  tables  of  marks in GAP provide an easy access to the classes of
  subgroups of their underlying groups (see 70.10).
  
  
  70.1 More about Tables of Marks
  
  Let G be a finite group with n conjugacy classes of subgroups C_1, C_2, ...,
  C_n  and  representatives  H_i  ∈ C_i, 1 ≤ i ≤ n. The table of marks of G is
  defined  to be the n × n matrix M = (m_ij) where the mark m_ij is the number
  of  fixed  points of the subgroup H_j in the action of G on the right cosets
  of H_i in G.
  
  Since  H_j  can  only  have  fixed  points  if  it  is  contained in a point
  stabilizer  the  matrix  M is lower triangular if the classes C_i are sorted
  according  to  the  condition that if H_i is contained in a conjugate of H_j
  then i ≤ j.
  
  Moreover,  the diagonal entries m_ii are nonzero since m_ii equals the index
  of  H_i  in its normalizer in G. Hence M is invertible. Since any transitive
  action of G is equivalent to an action on the cosets of a subgroup of G, one
  sees  that  the  table  of  marks  completely  characterizes  the set of all
  permutation representations of G.
  
  The  marks  m_ij  have further meanings. If H_1 is the trivial subgroup of G
  then each mark m_i1 in the first column of M is equal to the index of H_i in
  G  since  the trivial subgroup fixes all cosets of H_i. If H_n = G then each
  m_nj  in  the last row of M is equal to 1 since there is only one coset of G
  in  G.  In  general,  m_ij equals the number of conjugates of H_i containing
  H_j,  multiplied  by  the index of H_i in its normalizer in G. Moreover, the
  number  c_ij  of conjugates of H_j which are contained in H_i can be derived
  from the marks m_ij via the formula
  
  
  c_ij = ( m_ij m_j1 ) / ( m_i1 m_jj )
  
  .
  
  Both  the  marks  m_ij  and the numbers of subgroups c_ij are needed for the
  functions described in this chapter.
  
  A  brief  survey  of  properties  of  tables  of  marks and a description of
  algorithms for the interactive construction of tables of marks using GAP can
  be found in [Pfe97].
  
  
  70.2 Table of Marks Objects in GAP
  
  A  table  of  marks  of  a  group  G  in  GAP is represented by an immutable
  (see 12.6) object tom in the category IsTableOfMarks (70.6-2), with defining
  attributes  SubsTom  (70.7-1)  and  MarksTom  (70.7-1). These two attributes
  encode  the matrix of marks in a compressed form. The SubsTom (70.7-1) value
  of  tom  is  a  list  where  for each conjugacy class of subgroups the class
  numbers  of its subgroups are stored. These are exactly the positions in the
  corresponding  row  of  the  matrix of marks which have nonzero entries. The
  marks themselves are stored via the MarksTom (70.7-1) value of tom, which is
  a  list  that  contains  for  each entry in SubsTom( tom ) the corresponding
  nonzero value of the table of marks.
  
  It  is  possible to create table of marks objects that do not store a group,
  moreover  one  can  create  a  table  of marks object from a matrix of marks
  (see TableOfMarks  (70.3-1)).  So it may happen that a table of marks object
  in  GAP  is  in  fact not the table of marks of a group. To some extent, the
  consistency  of  a  table of marks object can be checked (see 70.9), but GAP
  knows no general way to prove or disprove that a given matrix of nonnegative
  integers  is  the  matrix of marks for a group. Many functions for tables of
  marks  work  well  without access to the group –this is one of the arguments
  why   tables   of   marks  are  so  useful–,  but  for  example  normalizers
  (see NormalizerTom  (70.9-4))  and derived subgroups (see DerivedSubgroupTom
  (70.9-2))  of subgroups are in general not uniquely determined by the matrix
  of marks.
  
  GAP  tables of marks are assumed to be in lower triangular form, that is, if
  a  subgroup  from  the  conjugacy  class  corresponding  to  the i-th row is
  contained  in a subgroup from the class corresponding to the j-th row j then
  i ≤ j.
  
  The  MarksTom  (70.7-1)  information  can be computed from the values of the
  attributes  NrSubsTom (70.7-2), LengthsTom (70.7-3), OrdersTom (70.7-2), and
  SubsTom (70.7-1). NrSubsTom (70.7-2) stores a list containing for each entry
  in  the  SubsTom  (70.7-1) value the corresponding number of conjugates that
  are  contained in a subgroup, LengthsTom (70.7-3) a list containing for each
  conjugacy  class  of  subgroups  its  length,  and OrdersTom (70.7-2) a list
  containing for each class of subgroups their order. So the MarksTom (70.7-1)
  value  of tom may be missing provided that the values of NrSubsTom (70.7-2),
  LengthsTom (70.7-3), and OrdersTom (70.7-2) are stored in tom.
  
  Additional  information  about a table of marks is needed by some functions.
  The class numbers of normalizers in G and the number of the derived subgroup
  of  G can be stored via appropriate attributes (see NormalizersTom (70.9-4),
  DerivedSubgroupTom (70.9-2)).
  
  If  tom  stores its group G and a bijection from the rows and columns of the
  matrix  of  marks  of  tom  to  the  classes  of subgroups of G then clearly
  normalizers,  derived  subgroup  etc. can be computed from this information.
  But  in  general a table of marks need not have access to G, for example tom
  might have been constructed from a generic table of marks (see 70.12), or as
  table   of   marks   of   a  factor  group  from  a  given  table  of  marks
  (see FactorGroupTom  (70.9-11)).  Access  to  the group G is provided by the
  attribute  UnderlyingGroup  (70.7-7)  if  this  value  is set. Access to the
  relevant  information  about conjugacy classes of subgroups of G –compatible
  with  the  ordering of rows and columns of the marks in tom– is signalled by
  the filter IsTableOfMarksWithGens (70.10-3).
  
  Several  examples  in  this  chapter require the GAP package TomLib (the GAP
  Library of Tables of Marks) to be available. If it is not yet loaded then we
  load it now.
  
    Example  
    gap> LoadPackage( "tomlib" );
    true
  
  
  
  70.3 Constructing Tables of Marks
  
  70.3-1 TableOfMarks
  
  TableOfMarks( G )  attribute
  TableOfMarks( string )  attribute
  TableOfMarks( matrix )  attribute
  
  In the first form, G must be a finite group, and TableOfMarks constructs the
  table of marks of G. This computation requires the knowledge of the complete
  subgroup  lattice  of  G (see LatticeSubgroups (39.20-1)). If the lattice is
  not  yet  stored  then it will be constructed. This may take a while if G is
  large. The result has the IsTableOfMarksWithGens (70.10-3) value true.
  
  In the second form, string must be a string, and TableOfMarks gets the table
  of  marks  with name string from the GAP library (see 70.13). If no table of
  marks with this name is contained in the library then fail is returned.
  
  In  the  third  form, matrix must be a matrix or a list of rows describing a
  lower  triangular  matrix  where the part above the diagonal is omitted. For
  such  an  argument  matrix,  TableOfMarks  returns  a  table of marks object
  (see 70.2)  for  which  matrix  is  the matrix of marks. Note that not every
  matrix  (containing  only  nonnegative  integers and having lower triangular
  shape)  describes  a  table  of  marks  of a group. Necessary conditions are
  checked   with  IsInternallyConsistent  (70.9-1)  (see 70.9),  and  fail  is
  returned  if  matrix  is  proved  not  to describe a matrix of marks; but if
  TableOfMarks  returns  a table of marks object created from a matrix then it
  may  still happen that this object does not describe the table of marks of a
  group.
  
  For  an  overview  of  operations  for  table  of  marks  objects,  see  the
  introduction to Chapter 70.
  
    Example  
    gap> tom:= TableOfMarks( AlternatingGroup( 5 ) );
    TableOfMarks( Alt( [ 1 .. 5 ] ) )
    gap> TableOfMarks( "J5" );
    fail
    gap> a5:= TableOfMarks( "A5" );
    TableOfMarks( "A5" )
    gap> mat:=
    > [ [ 60, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 30, 2, 0, 0, 0, 0, 0, 0, 0 ], 
    >   [ 20, 0, 2, 0, 0, 0, 0, 0, 0 ], [ 15, 3, 0, 3, 0, 0, 0, 0, 0 ], 
    >   [ 12, 0, 0, 0, 2, 0, 0, 0, 0 ], [ 10, 2, 1, 0, 0, 1, 0, 0, 0 ], 
    >   [ 6, 2, 0, 0, 1, 0, 1, 0, 0 ], [ 5, 1, 2, 1, 0, 0, 0, 1, 0 ], 
    >   [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ] ];;
    gap> TableOfMarks( mat );
    TableOfMarks( <9 classes> )
  
  
  The following TableOfMarks methods for a group are installed.
  
      If  the  group  is known to be cyclic then TableOfMarks constructs the
        table  of  marks  essentially without the group, instead the knowledge
        about the structure of cyclic groups is used.
  
      If  the  lattice  of  subgroups  is  already  stored in the group then
        TableOfMarks   computes   the   table   of   marks  from  the  lattice
        (see TableOfMarksByLattice (70.3-2)).
  
      If  the  group  is  known  to  be solvable then TableOfMarks takes the
        lattice  of  subgroups  (see LatticeSubgroups  (39.20-1)) of the group
        –which means that the lattice is computed if it is not yet stored– and
        then  computes  the  table  of  marks  from  it.  This  method is also
        accessible via the global function TableOfMarksByLattice (70.3-2).
  
      If  the  group  doesn't know its lattice of subgroups or its conjugacy
        classes of subgroups then the table of marks and the conjugacy classes
        of  subgroups  are  computed  at the same time by the cyclic extension
        method.  Only  the  table  of  marks  is  stored because the conjugacy
        classes  of  subgroups  or the lattice of subgroups can be easily read
        off (see LatticeSubgroupsByTom (70.3-3)).
  
  Conversely,  the  lattice  of subgroups of a group with known table of marks
  can   be   computed   using   the   table   of   marks,   via  the  function
  LatticeSubgroupsByTom  (70.3-3).  This  is  also  installed  as a method for
  LatticeSubgroups (39.20-1).
  
  70.3-2 TableOfMarksByLattice
  
  TableOfMarksByLattice( G )  function
  
  TableOfMarksByLattice  computes  the  table of marks of the group G from the
  lattice  of  subgroups  of  G. This lattice is computed via LatticeSubgroups
  (39.20-1)  if  it is not yet stored in G. The function TableOfMarksByLattice
  is  installed  as a method for TableOfMarks (70.3-1) for solvable groups and
  groups  with  stored subgroup lattice, and is available as a global variable
  only in order to provide explicit access to this method.
  
  70.3-3 LatticeSubgroupsByTom
  
  LatticeSubgroupsByTom( G )  function
  
  LatticeSubgroupsByTom  computes the lattice of subgroups of G from the table
  of marks of G, using RepresentativeTom (70.10-4).
  
  
  70.4 Printing Tables of Marks
  
  70.4-1 ViewObj
  
  ViewObj( tom )  method
  
  The  default  ViewObj  (6.3-5)  method for tables of marks prints the string
  "TableOfMarks",  followed  by  –if  known–  the  identifier  (see Identifier
  (70.7-9))  or  the  group  of  the  table  of marks enclosed in brackets; if
  neither  group  nor  identifier  are known then just the number of conjugacy
  classes of subgroups is printed instead.
  
  70.4-2 PrintObj
  
  PrintObj( tom )  method
  
  The  default  PrintObj  (6.3-5)  method for tables of marks does the same as
  ViewObj  (6.3-5), except that PrintObj (6.3-5) is used for the group instead
  of ViewObj (6.3-5).
  
  70.4-3 Display
  
  Display( tom[, arec] )  method
  
  The  default  Display  (6.3-6)  method  for  a table of marks tom produces a
  formatted  output  of  the marks in tom. Each line of output begins with the
  number  of  the corresponding class of subgroups. This number is repeated if
  the  output spreads over several pages. The number of columns printed at one
  time depends on the actual line length, which can be accessed and changed by
  the function SizeScreen (6.12-1).
  
  An  interactive  variant of Display (6.3-6) is the Browse (Browse???) method
  for  tables  of marks that is provided by the GAP package Browse, see Browse
  (Browse, for tables of marks???).
  
  The  optional  second argument arec of Display (6.3-6) can be used to change
  the  default  style  for displaying a table of marks. arec must be a record,
  its relevant components are the following.
  
  classes
        a  list  of  class  numbers to select only the rows and columns of the
        matrix that correspond to this list for printing,
  
  form
        one  of the strings "subgroups", "supergroups"; in the former case, at
        position (i,j) of the matrix the number of conjugates of H_j contained
        in  H_i  is  printed,  and  in  the latter case, at position (i,j) the
        number of conjugates of H_i which contain H_j is printed.
  
    Example  
    gap> tom:= TableOfMarks( "A5" );;
    gap> Display( tom );
    1:  60
    2:  30 2
    3:  20 . 2
    4:  15 3 . 3
    5:  12 . . . 2
    6:  10 2 1 . . 1
    7:   6 2 . . 1 . 1
    8:   5 1 2 1 . . . 1
    9:   1 1 1 1 1 1 1 1 1
    
    gap> Display( tom, rec( classes:= [ 1, 2, 3, 4, 8 ] ) );
    1:  60
    2:  30 2
    3:  20 . 2
    4:  15 3 . 3
    8:   5 1 2 1 1
    
    gap> Display( tom, rec( form:= "subgroups" ) );
    1:  1
    2:  1  1
    3:  1  .  1
    4:  1  3  . 1
    5:  1  .  . . 1
    6:  1  3  1 . .  1
    7:  1  5  . . 1  . 1
    8:  1  3  4 1 .  . . 1
    9:  1 15 10 5 6 10 6 5 1
    
    gap> Display( tom, rec( form:= "supergroups" ) );
    1:   1
    2:  15 1
    3:  10 . 1
    4:   5 1 . 1
    5:   6 . . . 1
    6:  10 2 1 . . 1
    7:   6 2 . . 1 . 1
    8:   5 1 2 1 . . . 1
    9:   1 1 1 1 1 1 1 1 1
    
  
  
  
  70.5 Sorting Tables of Marks
  
  70.5-1 SortedTom
  
  SortedTom( tom, perm )  operation
  
  SortedTom  returns  a table of marks where the rows and columns of the table
  of marks tom are reordered according to the permutation perm.
  
  Note  that  in each table of marks in GAP, the matrix of marks is assumed to
  have  lower  triangular  shape  (see 70.2). If the permutation perm does not
  have this property then the functions for tables of marks might return wrong
  results when applied to the output of SortedTom.
  
  The  returned table of marks has only those attribute values stored that are
  known for tom and listed in TableOfMarksComponents (70.6-4).
  
    Example  
    gap> tom:= TableOfMarksCyclic( 6 );;  Display( tom );
    1:  6
    2:  3 3
    3:  2 . 2
    4:  1 1 1 1
    
    gap> sorted:= SortedTom( tom, (2,3) );;  Display( sorted );
    1:  6
    2:  2 2
    3:  3 . 3
    4:  1 1 1 1
    
    gap> wrong:= SortedTom( tom, (1,2) );;  Display( wrong );
    1:  3
    2:  . 6
    3:  . 2 2
    4:  1 1 1 1
    
  
  
  70.5-2 PermutationTom
  
  PermutationTom( tom )  attribute
  
  For the table of marks tom of the group G stored as UnderlyingGroup (70.7-7)
  value of tom, PermutationTom is a permutation π such that the i-th conjugacy
  class  of  subgroups  of  G belongs to the i^π-th column and row of marks in
  tom.
  
  This attribute value is bound only if tom was obtained from another table of
  marks  by  permuting with SortedTom (70.5-1), and there is no default method
  to compute its value.
  
  The  attribute  is  necessary  because  the original and the sorted table of
  marks  have the same identifier and the same group, and information computed
  from  the  group may depend on the ordering of marks, for example the fusion
  from the ordinary character table of G into tom.
  
    Example  
    gap> MarksTom( tom )[2];
    [ 3, 3 ]
    gap> MarksTom( sorted )[2];
    [ 2, 2 ]
    gap> HasPermutationTom( sorted );
    true
    gap> PermutationTom( sorted );
    (2,3)
  
  
  
  70.6 Technical Details about Tables of Marks
  
  70.6-1 InfoTom
  
  InfoTom info class
  
  is the info class for computations concerning tables of marks.
  
  70.6-2 IsTableOfMarks
  
  IsTableOfMarks( obj )  Category
  
  Each table of marks belongs to this category.
  
  70.6-3 TableOfMarksFamily
  
  TableOfMarksFamily family
  
  Each table of marks belongs to this family.
  
  70.6-4 TableOfMarksComponents
  
  TableOfMarksComponents global variable
  
  The  list  TableOfMarksComponents  is  used  when a table of marks object is
  created     from    a    record    via    ConvertToTableOfMarks    (70.6-5).
  TableOfMarksComponents  contains at position 2i-1 a name of an attribute and
  at position 2i the corresponding attribute getter function.
  
  70.6-5 ConvertToTableOfMarks
  
  ConvertToTableOfMarks( record )  function
  
  ConvertToTableOfMarks    converts    a    record    with   components   from
  TableOfMarksComponents  (70.6-4)  into  a  table  of  marks  object with the
  corresponding attributes.
  
    Example  
    gap> record:= rec( MarksTom:= [ [ 4 ], [ 2, 2 ], [ 1, 1, 1 ] ],
    >  SubsTom:= [ [ 1 ], [ 1, 2 ], [ 1, 2, 3 ] ] );;
    gap> ConvertToTableOfMarks( record );;
    gap> record;
    TableOfMarks( <3 classes> )
  
  
  
  70.7 Attributes of Tables of Marks
  
  70.7-1 MarksTom
  
  MarksTom( tom )  attribute
  SubsTom( tom )  attribute
  
  The  matrix  of  marks  (see 70.1)  of the table of marks tom is stored in a
  compressed  form  where zeros are omitted, using the attributes MarksTom and
  SubsTom.  If  M  is the square matrix of marks of tom (see MatTom (70.7-10))
  then the SubsTom value of tom is a list that contains at position i the list
  of  all  positions of nonzero entries of the i-th row of M, and the MarksTom
  value  of  tom  is  a  list  that  contains  at  position  i the list of the
  corresponding marks.
  
  MarksTom  and SubsTom are defining attributes of tables of marks (see 70.2).
  There  is no default method for computing the SubsTom value, and the default
  MarksTom  method  needs  the  values  of  NrSubsTom  (70.7-2)  and OrdersTom
  (70.7-2).
  
    Example  
    gap> a5:= TableOfMarks( "A5" );
    TableOfMarks( "A5" )
    gap> MarksTom( a5 );
    [ [ 60 ], [ 30, 2 ], [ 20, 2 ], [ 15, 3, 3 ], [ 12, 2 ], 
      [ 10, 2, 1, 1 ], [ 6, 2, 1, 1 ], [ 5, 1, 2, 1, 1 ], 
      [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ] ]
    gap> SubsTom( a5 );
    [ [ 1 ], [ 1, 2 ], [ 1, 3 ], [ 1, 2, 4 ], [ 1, 5 ], [ 1, 2, 3, 6 ], 
      [ 1, 2, 5, 7 ], [ 1, 2, 3, 4, 8 ], [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ] ]
  
  
  70.7-2 NrSubsTom
  
  NrSubsTom( tom )  attribute
  OrdersTom( tom )  attribute
  
  Instead  of  storing the marks (see MarksTom (70.7-1)) of the table of marks
  tom  one  can  use  a  matrix which contains at position (i,j) the number of
  subgroups  of  conjugacy  class  j  that  are contained in one member of the
  conjugacy  class  i.  These  values are stored in the NrSubsTom value in the
  same way as the marks in the MarksTom (70.7-1) value.
  
  OrdersTom  returns  a  list  that  contains  at  position  i  the order of a
  representative of the i-th conjugacy class of subgroups of tom.
  
  One  can  compute  the  NrSubsTom  and  OrdersTom  values  from the MarksTom
  (70.7-1) value of tom and vice versa.
  
    Example  
    gap> NrSubsTom( a5 );
    [ [ 1 ], [ 1, 1 ], [ 1, 1 ], [ 1, 3, 1 ], [ 1, 1 ], [ 1, 3, 1, 1 ], 
      [ 1, 5, 1, 1 ], [ 1, 3, 4, 1, 1 ], [ 1, 15, 10, 5, 6, 10, 6, 5, 1 ] 
     ]
    gap> OrdersTom( a5 );
    [ 1, 2, 3, 4, 5, 6, 10, 12, 60 ]
  
  
  70.7-3 LengthsTom
  
  LengthsTom( tom )  attribute
  
  For  a  table  of marks tom, LengthsTom returns a list of the lengths of the
  conjugacy classes of subgroups.
  
    Example  
    gap> LengthsTom( a5 );
    [ 1, 15, 10, 5, 6, 10, 6, 5, 1 ]
  
  
  70.7-4 ClassTypesTom
  
  ClassTypesTom( tom )  attribute
  
  ClassTypesTom distinguishes isomorphism types of the classes of subgroups of
  the  table of marks tom as far as this is possible from the SubsTom (70.7-1)
  and MarksTom (70.7-1) values of tom.
  
  Two  subgroups  are  clearly  not  isomorphic if they have different orders.
  Moreover,  isomorphic subgroups must contain the same number of subgroups of
  each type.
  
  Each  type  is  represented by a positive integer. ClassTypesTom returns the
  list which contains for each class of subgroups its corresponding type.
  
    Example  
    gap> a6:= TableOfMarks( "A6" );;
    gap> ClassTypesTom( a6 );
    [ 1, 2, 3, 3, 4, 5, 6, 6, 7, 7, 8, 9, 10, 11, 11, 12, 13, 13, 14, 15, 
      15, 16 ]
  
  
  70.7-5 ClassNamesTom
  
  ClassNamesTom( tom )  attribute
  
  ClassNamesTom   constructs  generic  names  for  the  conjugacy  classes  of
  subgroups of the table of marks tom. In general, the generic name of a class
  of non-cyclic subgroups consists of three parts and has the form "(o)_{t}l",
  where   o  indicates  the  order  of  the  subgroup,  t  is  a  number  that
  distinguishes  different  types  of  subgroups of the same order, and l is a
  letter  that  distinguishes classes of subgroups of the same type and order.
  The  type  of  a  subgroup  is determined by the numbers of its subgroups of
  other  types  (see ClassTypesTom  (70.7-4)).  This  is  slightly weaker than
  isomorphism.
  
  The  letter is omitted if there is only one class of subgroups of that order
  and  type, and the type is omitted if there is only one class of that order.
  Moreover,  the  braces {} around the type are omitted if the type number has
  only one digit.
  
  For  classes  of  cyclic  subgroups, the parentheses round the order and the
  type  are  omitted.  Hence  the  most general form of their generic names is
  "o,l".  Again,  the  letter  is omitted if there is only one class of cyclic
  subgroups of that order.
  
    Example  
    gap> ClassNamesTom( a6 );
    [ "1", "2", "3a", "3b", "5", "4", "(4)_2a", "(4)_2b", "(6)a", "(6)b", 
      "(8)", "(9)", "(10)", "(12)a", "(12)b", "(18)", "(24)a", "(24)b", 
      "(36)", "(60)a", "(60)b", "(360)" ]
  
  
  70.7-6 FusionsTom
  
  FusionsTom( tom )  attribute
  
  For  a table of marks tom, FusionsTom is a list of fusions into other tables
  of  marks.  Each  fusion  is a list of length two, the first entry being the
  Identifier  (70.7-9))  value  of the image table, the second entry being the
  list of images of the class positions of tom in the image table.
  
  This  attribute  is  mainly  used  for  tables  of  marks in the GAP library
  (see 70.13).
  
    Example  
    gap> fus:= FusionsTom( a6 );;
    gap> fus[1];
    [ "L3(4)", 
      [ 1, 2, 3, 3, 14, 5, 9, 7, 15, 15, 24, 26, 27, 32, 33, 50, 57, 55, 
          63, 73, 77, 90 ] ]
  
  
  70.7-7 UnderlyingGroup
  
  UnderlyingGroup( tom )  attribute
  
  UnderlyingGroup  is used to access an underlying group that is stored on the
  table  of  marks  tom.  There  is no default method to compute an underlying
  group if it is not stored.
  
    Example  
    gap> UnderlyingGroup( a6 );
    Group([ (1,2)(3,4), (1,2,4,5)(3,6) ])
  
  
  70.7-8 IdempotentsTom
  
  IdempotentsTom( tom )  attribute
  IdempotentsTomInfo( tom )  attribute
  
  IdempotentsTom  encodes  the  idempotents  of  the  integral  Burnside  ring
  described  by  the  table  of  marks  tom.  The  return value is a list l of
  positive   integers  such  that  each  row  vector  describing  a  primitive
  idempotent  has  value 1 at all positions with the same entry in l, and 0 at
  all other positions.
  
  According   to   A. Dress [Dre69]   (see  also [Pfe97]),  these  idempotents
  correspond  to the classes of perfect subgroups, and each such idempotent is
  the  characteristic  function  of  all  those subgroups that arise by cyclic
  extension  from  the corresponding perfect subgroup (see CyclicExtensionsTom
  (70.9-7)).
  
  IdempotentsTomInfo  returns  a  record  with  components fixpointvectors and
  primidems,  both  bound to lists. The i-th entry of the fixpointvectors list
  is  the  0-1-vector  describing  the i-th primitive idempotent, and the i-th
  entry  of  primidems  is the decomposition of this idempotent in the rows of
  tom.
  
    Example  
    gap> IdempotentsTom( a5 );
    [ 1, 1, 1, 1, 1, 1, 1, 1, 9 ]
    gap> IdempotentsTomInfo( a5 );
    rec( 
      fixpointvectors := [ [ 1, 1, 1, 1, 1, 1, 1, 1, 0 ], 
          [ 0, 0, 0, 0, 0, 0, 0, 0, 1 ] ], 
      primidems := [ [ 1, -2, -1, 0, 0, 1, 1, 1 ], 
          [ -1, 2, 1, 0, 0, -1, -1, -1, 1 ] ] )
  
  
  70.7-9 Identifier
  
  Identifier( tom )  attribute
  
  The  identifier of a table of marks tom is a string. It is used for printing
  the  table  of  marks  (see 70.4)  and  in  fusions  between tables of marks
  (see FusionsTom (70.7-6)).
  
  If  tom  is  a  table  of  marks  from  the  GAP  library of tables of marks
  (see 70.13)  then  it  has  an identifier, and if tom was constructed from a
  group with Name (12.8-2) then this name is chosen as Identifier value. There
  is no default method to compute an identifier in all other cases.
  
    Example  
    gap> Identifier( a5 );
    "A5"
  
  
  70.7-10 MatTom
  
  MatTom( tom )  attribute
  
  MatTom  returns  the square matrix of marks (see 70.1) of the table of marks
  tom  which  is  stored  in  a  compressed form using the attributes MarksTom
  (70.7-1)  and  SubsTom  (70.7-1) This may need substantially more space than
  the values of MarksTom (70.7-1) and SubsTom (70.7-1).
  
    Example  
    gap> MatTom( a5 );
    [ [ 60, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 30, 2, 0, 0, 0, 0, 0, 0, 0 ], 
      [ 20, 0, 2, 0, 0, 0, 0, 0, 0 ], [ 15, 3, 0, 3, 0, 0, 0, 0, 0 ], 
      [ 12, 0, 0, 0, 2, 0, 0, 0, 0 ], [ 10, 2, 1, 0, 0, 1, 0, 0, 0 ], 
      [ 6, 2, 0, 0, 1, 0, 1, 0, 0 ], [ 5, 1, 2, 1, 0, 0, 0, 1, 0 ], 
      [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ] ]
  
  
  70.7-11 MoebiusTom
  
  MoebiusTom( tom )  attribute
  
  MoebiusTom  computes  the  Möbius values both of the subgroup lattice of the
  group  G  with  table  of marks tom and of the poset of conjugacy classes of
  subgroups  of  G.  It  returns  a record where the component mu contains the
  Möbius  values  of  the  subgroup lattice, and the component nu contains the
  Möbius values of the poset.
  
  Moreover,  according  to  an  observation  of  Isaacs  et  al. (see [HIÖ89],
  [Pah93]), the values on the subgroup lattice often can be derived from those
  of the poset of conjugacy classes. These expected values are returned in the
  component  ex, and the list of numbers of those subgroups where the expected
  value  does not coincide with the actual value are returned in the component
  hyp.  For  the  computation  of  these  values,  the position of the derived
  subgroup  of  G  is  needed  (see DerivedSubgroupTom (70.9-2)). If it is not
  uniquely determined then the result does not have the components ex and hyp.
  
    Example  
    gap> MoebiusTom( a5 );
    rec( ex := [ -60, 4, 2,,, -1, -1, -1, 1 ], hyp := [  ], 
      mu := [ -60, 4, 2,,, -1, -1, -1, 1 ], 
      nu := [ -1, 2, 1,,, -1, -1, -1, 1 ] )
    gap> tom:= TableOfMarks( "M12" );;
    gap> moebius:= MoebiusTom( tom );;
    gap> moebius.hyp;
    [ 1, 2, 4, 16, 39, 45, 105 ]
    gap> moebius.mu[1];  moebius.ex[1];
    95040
    190080
  
  
  70.7-12 WeightsTom
  
  WeightsTom( tom )  attribute
  
  WeightsTom  extracts  the  weights  from  the  table of marks tom, i.e., the
  diagonal  entries of the matrix of marks (see MarksTom (70.7-1)), indicating
  the index of a subgroup in its normalizer.
  
    Example  
    gap> wt:= WeightsTom( a5 );
    [ 60, 2, 2, 3, 2, 1, 1, 1, 1 ]
  
  
  This  information may be used to obtain the numbers of conjugate supergroups
  from the marks.
  
    Example  
    gap> marks:= MarksTom( a5 );;
    gap> List( [ 1 .. 9 ], x -> marks[x] / wt[x] );
    [ [ 1 ], [ 15, 1 ], [ 10, 1 ], [ 5, 1, 1 ], [ 6, 1 ], [ 10, 2, 1, 1 ],
      [ 6, 2, 1, 1 ], [ 5, 1, 2, 1, 1 ], [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ] ]
  
  
  
  70.8 Properties of Tables of Marks
  
  For  a  table  of  marks tom of a group G, the following properties have the
  same  meaning  as  the  corresponding  properties  for G. Additionally, if a
  positive  integer  sub is given as the second argument then the value of the
  corresponding property for the sub-th class of subgroups of tom is returned.
  
  70.8-1 IsAbelianTom
  
  IsAbelianTom( tom[, sub] )  property
  IsCyclicTom( tom[, sub] )  property
  IsNilpotentTom( tom[, sub] )  property
  IsPerfectTom( tom[, sub] )  property
  IsSolvableTom( tom[, sub] )  property
  
    Example  
    gap> tom:= TableOfMarks( "A5" );;
    gap> IsAbelianTom( tom );  IsPerfectTom( tom );
    false
    true
    gap> IsAbelianTom( tom, 3 );  IsNilpotentTom( tom, 7 );
    true
    false
    gap> IsPerfectTom( tom, 7 );  IsSolvableTom( tom, 7 );
    false
    true
    gap> for i in [ 1 .. 6 ] do
    > Print( i, ": ", IsCyclicTom(a5, i), "  " );
    > od;  Print( "\n" );
    1: true  2: true  3: true  4: false  5: true  6: false  
  
  
  
  70.9 Other Operations for Tables of Marks
  
  70.9-1 IsInternallyConsistent
  
  IsInternallyConsistent( tom )  method
  
  For  a  table  of  marks  tom,  IsInternallyConsistent decomposes all tensor
  products  of  rows  of tom. It returns true if all decomposition numbers are
  nonnegative   integers,   and   false  otherwise.  This  provides  a  strong
  consistency check for a table of marks.
  
  70.9-2 DerivedSubgroupTom
  
  DerivedSubgroupTom( tom, sub )  operation
  DerivedSubgroupsTom( tom )  function
  
  For  a  table  of  marks  tom and a positive integer sub, DerivedSubgroupTom
  returns either a positive integer i or a list l of positive integers. In the
  former case, the result means that the derived subgroups of the subgroups in
  the sub-th class of tom lie in the i-th class. In the latter case, the class
  of  the derived subgroups could not be uniquely determined, and the position
  of the class of derived subgroups is an entry of l.
  
  Values  computed  with  DerivedSubgroupTom  are  stored  using the attribute
  DerivedSubgroupsTomPossible (70.9-3).
  
  DerivedSubgroupsTom  is  just  the list of DerivedSubgroupTom values for all
  values of sub.
  
  70.9-3 DerivedSubgroupsTomPossible
  
  DerivedSubgroupsTomPossible( tom )  attribute
  DerivedSubgroupsTomUnique( tom )  attribute
  
  Let   tom   be   a   table   of   marks.   The   value   of   the  attribute
  DerivedSubgroupsTomPossible  is  a list in which the value at position i –if
  bound– is a positive integer or a list; the meaning of the entry is the same
  as in DerivedSubgroupTom (70.9-2).
  
  If  the  value  of  the attribute DerivedSubgroupsTomUnique is known for tom
  then  it  is  a list of positive integers, the value at position i being the
  position of the class of derived subgroups of the i-th class of subgroups in
  tom.
  
  The derived subgroups are in general not uniquely determined by the table of
  marks if no UnderlyingGroup (70.7-7) value is stored, so there is no default
  method   for  DerivedSubgroupsTomUnique.  But  in  some  cases  the  derived
  subgroups are explicitly set when the table of marks is constructed. In this
  case,   DerivedSubgroupTom   (70.9-2)   does   not   set   values   in   the
  DerivedSubgroupsTomPossible list.
  
  The  DerivedSubgroupsTomUnique  value  is  automatically  set  when the last
  missing  unique  value is entered in the DerivedSubgroupsTomPossible list by
  DerivedSubgroupTom (70.9-2).
  
  70.9-4 NormalizerTom
  
  NormalizerTom( tom, sub )  operation
  NormalizersTom( tom )  attribute
  
  Let tom be the table of marks of a group G, say. NormalizerTom tries to find
  the  conjugacy  class of the normalizer N in G of a subgroup U in the sub-th
  class  of tom. The return value is either the list of class numbers of those
  subgroups  that  have  the  right  size  and  contain  the  subgroup and all
  subgroups  that clearly contain it as a normal subgroup, or the class number
  of  the  normalizer if it is uniquely determined by these conditions. If tom
  knows  the subgroup lattice of G (see IsTableOfMarksWithGens (70.10-3)) then
  all  normalizers  are uniquely determined. NormalizerTom should never return
  an empty list.
  
  NormalizersTom  returns  the list of positions of the classes of normalizers
  of  subgroups  in  tom.  In  addition  to the criteria for a single class of
  subgroup  used  by  NormalizerTom,  the  approximations  of  normalizers for
  several   classes  are  used  and  thus  NormalizersTom  may  return  better
  approximations than NormalizerTom.
  
    Example  
    gap> NormalizerTom( a5, 4 );
    8
    gap> NormalizersTom( a5 );
    [ 9, 4, 6, 8, 7, 6, 7, 8, 9 ]
  
  
  The  example  shows  that  a subgroup with class number 4 in A_5 (which is a
  Kleinian  four  group)  is  normalized  by a subgroup in class 8. This class
  contains the subgroups of A_5 which are isomorphic to A_4.
  
  70.9-5 ContainedTom
  
  ContainedTom( tom, sub1, sub2 )  operation
  
  ContainedTom  returns  the number of subgroups in class sub1 of the table of
  marks tom that are contained in one fixed member of the class sub2.
  
    Example  
    gap> ContainedTom( a5, 3, 5 );  ContainedTom( a5, 3, 8 );
    0
    4
  
  
  70.9-6 ContainingTom
  
  ContainingTom( tom, sub1, sub2 )  operation
  
  ContainingTom  returns the number of subgroups in class sub2 of the table of
  marks tom that contain one fixed member of the class sub1.
  
    Example  
    gap> ContainingTom( a5, 3, 5 );  ContainingTom( a5, 3, 8 );
    0
    2
  
  
  70.9-7 CyclicExtensionsTom
  
  CyclicExtensionsTom( tom, p )  operation
  CyclicExtensionsTom( tom[, list] )  attribute
  
  According  to  A. Dress [Dre69],  two  columns of the table of marks tom are
  equal  modulo  the  prime  p  if and only if the corresponding subgroups are
  connected by a chain of normal extensions of order p.
  
  Called  with  tom  and  p,  CyclicExtensionsTom  returns the classes of this
  equivalence relation.
  
  In  the  second form, list must be a list of primes, and the return value is
  the list of classes of the relation obtained by considering chains of normal
  extensions  of  prime  order where all primes are in list. The default value
  for list is the set of prime divisors of the order of the group of tom.
  
  (This  information  is  not used by NormalizerTom (70.9-4) although it might
  give additional restrictions in the search of normalizers.)
  
    Example  
    gap> CyclicExtensionsTom( a5, 2 );
    [ [ 1, 2, 4 ], [ 3, 6 ], [ 5, 7 ], [ 8 ], [ 9 ] ]
  
  
  70.9-8 DecomposedFixedPointVector
  
  DecomposedFixedPointVector( tom, fix )  operation
  
  Let  tom  be the table of marks of the group G, say, and let fix be a vector
  of  fixed point numbers w.r.t. an action of G, i.e., a vector which contains
  for  each  class  of  subgroups  the  number of fixed points under the given
  action.  DecomposedFixedPointVector  returns  the  decomposition of fix into
  rows   of   the   table  of  marks.  This  decomposition  corresponds  to  a
  decomposition  of the action into transitive constituents. Trailing zeros in
  fix may be omitted.
  
    Example  
    gap> DecomposedFixedPointVector( a5, [ 16, 4, 1, 0, 1, 1, 1 ] );
    [ 0, 0, 0, 0, 0, 1, 1 ]
  
  
  The  vector  fix may be any vector of integers. The resulting decomposition,
  however, will not be integral, in general.
  
    Example  
    gap> DecomposedFixedPointVector( a5, [ 0, 0, 0, 0, 1, 1 ] );
    [ 2/5, -1, -1/2, 0, 1/2, 1 ]
  
  
  70.9-9 EulerianFunctionByTom
  
  EulerianFunctionByTom( tom, n[, sub] )  operation
  
  Called  with  two  arguments,  EulerianFunctionByTom  computes  the Eulerian
  function  (see EulerianFunction  (39.16-3)) of the underlying group G of the
  table  of  marks  tom, that is, the number of n-tuples of elements in G that
  generate G. If the optional argument sub is given then EulerianFunctionByTom
  computes  the  Eulerian  function  of  each  subgroup in the sub-th class of
  subgroups of tom.
  
  For  a  group  G  whose  table  of  marks is known, EulerianFunctionByTom is
  installed as a method for EulerianFunction (39.16-3).
  
    Example  
    gap> EulerianFunctionByTom( a5, 2 );
    2280
    gap> EulerianFunctionByTom( a5, 3 );
    200160
    gap> EulerianFunctionByTom( a5, 2, 3 );
    8
  
  
  70.9-10 IntersectionsTom
  
  IntersectionsTom( tom, sub1, sub2 )  operation
  
  The  intersections of the groups in the sub1-th conjugacy class of subgroups
  of  the  table of marks tom with the groups in the sub2-th conjugacy classes
  of  subgroups  of tom are determined up to conjugacy by the decomposition of
  the tensor product of their rows of marks. IntersectionsTom returns a list l
  that  describes  this decomposition. The i-th entry in l is the multiplicity
  of groups in the i-th conjugacy class as an intersection.
  
    Example  
    gap> IntersectionsTom( a5, 8, 8 );
    [ 0, 0, 1, 0, 0, 0, 0, 1 ]
  
  
  Any  two subgroups of class number 8 (A_4) of A_5 are either equal and their
  intersection  has  again  class  number  8,  or their intersection has class
  number 3, and is a cyclic subgroup of order 3.
  
  70.9-11 FactorGroupTom
  
  FactorGroupTom( tom, n )  operation
  
  For a table of marks tom of the group G, say, and the normal subgroup N of G
  corresponding  to the n-th class of subgroups of tom, FactorGroupTom returns
  the table of marks of the factor group G / N.
  
    Example  
    gap> s4:= TableOfMarks( SymmetricGroup( 4 ) );
    TableOfMarks( Sym( [ 1 .. 4 ] ) )
    gap> LengthsTom( s4 );
    [ 1, 3, 6, 4, 1, 3, 3, 4, 3, 1, 1 ]
    gap> OrdersTom( s4 );
    [ 1, 2, 2, 3, 4, 4, 4, 6, 8, 12, 24 ]
    gap> s3:= FactorGroupTom( s4, 5 );
    TableOfMarks( Group([ f1, f2 ]) )
    gap> Display( s3 );
    1:  6
    2:  3 1
    3:  2 . 2
    4:  1 1 1 1
    
  
  
  70.9-12 MaximalSubgroupsTom
  
  MaximalSubgroupsTom( tom[, sub] )  attribute
  
  Called  with  a  table  of  marks tom, MaximalSubgroupsTom returns a list of
  length  two,  the  first entry being the list of positions of the classes of
  maximal subgroups of the whole group of tom, the second entry being the list
  of class lengths of these groups.
  
  Called  with  a  table of marks tom and a position sub, the same information
  for the sub-th class of subgroups is returned.
  
    Example  
    gap> MaximalSubgroupsTom( s4 );
    [ [ 10, 9, 8 ], [ 1, 3, 4 ] ]
    gap> MaximalSubgroupsTom( s4, 10 );
    [ [ 5, 4 ], [ 1, 4 ] ]
  
  
  70.9-13 MinimalSupergroupsTom
  
  MinimalSupergroupsTom( tom, sub )  operation
  
  For  a  table  of  marks tom, MinimalSupergroupsTom returns a list of length
  two,  the  first entry being the list of positions of the classes containing
  the  minimal  supergroups  of the groups in the sub-th class of subgroups of
  tom, the second entry being the list of class lengths of these groups.
  
    Example  
    gap> MinimalSupergroupsTom( s4, 5 );
    [ [ 9, 10 ], [ 3, 1 ] ]
  
  
  
  70.10 Accessing Subgroups via Tables of Marks
  
  Let tom be the table of marks of the group G, and assume that tom has access
  to  G via the UnderlyingGroup (70.7-7) value. Then it makes sense to use tom
  and  its  ordering  of  conjugacy  classes  of  subgroups  of  G for storing
  information  for  constructing representatives of these classes. The group G
  is  in  general not sufficient for this, tom needs more information; this is
  available  if  and only if the IsTableOfMarksWithGens (70.10-3) value of tom
  is  true.  In  this  case,  RepresentativeTom (70.10-4) can be used to get a
  subgroup of the i-th class, for all i.
  
  GAP  provides  two  different  possibilities  to  store  generators  of  the
  representatives  of  classes  of  subgroups. The first is implemented by the
  attribute  GeneratorsSubgroupsTom  (70.10-1), which uses explicit generators
  of  the  subgroups.  The second, more general, possibility is implemented by
  the   attribute   StraightLineProgramsTom   (70.10-2),   which  encodes  the
  generators  as  straight  line  programs  (see 37.8)  that  evaluate  to the
  generators  in question when applied to standard generators of G. This means
  that on the one hand, standard generators of G must be known in order to use
  StraightLineProgramsTom  (70.10-2).  On  the  other  hand, the straight line
  programs  allow one to compute easily generators not only of a subgroup U of
  G but also generators of the image of U in any representation of G, provided
  that   one   knows  standard  generators  of  the  image  of  G  under  this
  representation.  See  the  manual  of  the package TomLib for details and an
  example.
  
  70.10-1 GeneratorsSubgroupsTom
  
  GeneratorsSubgroupsTom( tom )  attribute
  
  Let  tom  be  a  table  of marks with IsTableOfMarksWithGens (70.10-3) value
  true.  Then  GeneratorsSubgroupsTom  returns a list of length two, the first
  entry  being  a  list  l  of elements of the group stored as UnderlyingGroup
  (70.7-7)  value  of  tom,  the  second  entry  being a list that contains at
  position  i  a list of positions in l of generators of a representative of a
  subgroup in class i.
  
  The  GeneratorsSubgroupsTom value is known for all tables of marks that have
  been computed with TableOfMarks (70.3-1) from a group, and there is a method
  to  compute  the  value  for  a table of marks that admits RepresentativeTom
  (70.10-4).
  
  70.10-2 StraightLineProgramsTom
  
  StraightLineProgramsTom( tom )  attribute
  
  For  a  table of marks tom with IsTableOfMarksWithGens (70.10-3) value true,
  StraightLineProgramsTom  returns a list that contains at position i either a
  list  of  straight  line  programs  or  a  straight line program (see 37.8),
  encoding  the  generators of a representative of the i-th conjugacy class of
  subgroups  of UnderlyingGroup( tom ); in the former case, each straight line
  program  returns  a  generator,  in the latter case, the program returns the
  list of generators.
  
  There is no default method to compute the StraightLineProgramsTom value of a
  table of marks if they are not yet stored. The value is known for all tables
  of marks that belong to the GAP library of tables of marks (see 70.13).
  
  70.10-3 IsTableOfMarksWithGens
  
  IsTableOfMarksWithGens( tom )  filter
  
  This  filter  shall  express  the  union  of  the filters IsTableOfMarks and
  HasStraightLineProgramsTom and IsTableOfMarks and HasGeneratorsSubgroupsTom.
  If a table of marks tom has this filter set then tom can be asked to compute
  information  that is in general not uniquely determined by a table of marks,
  for  example  the positions of derived subgroups or normalizers of subgroups
  (see DerivedSubgroupTom (70.9-2), NormalizerTom (70.9-4)).
  
    Example  
    gap> a5:= TableOfMarks( "A5" );;  IsTableOfMarksWithGens( a5 );
    true
    gap> HasGeneratorsSubgroupsTom( a5 );  HasStraightLineProgramsTom( a5 );
    false
    true
    gap> alt5:= TableOfMarks( AlternatingGroup( 5 ) );;
    gap> IsTableOfMarksWithGens( alt5 );
    true
    gap> HasGeneratorsSubgroupsTom(alt5); HasStraightLineProgramsTom(alt5);
    true
    false
    gap> progs:= StraightLineProgramsTom( a5 );;
    gap> OrdersTom( a5 );
    [ 1, 2, 3, 4, 5, 6, 10, 12, 60 ]
    gap> IsCyclicTom( a5, 4 );
    false
    gap> Length( progs[4] );
    2
    gap> progs[4][1];
    <straight line program>
    gap> # first generator of an el. ab group of order 4:
    gap> Display( progs[4][1] );
    # input:
    r:= [ g1, g2 ];
    # program:
    r[3]:= r[2]*r[1];
    r[4]:= r[3]*r[2]^-1*r[1]*r[3]*r[2]^-1*r[1]*r[2];
    # return value:
    r[4]
    gap> x:= [ [ Z(2)^0, 0*Z(2) ], [ Z(2^2), Z(2)^0 ] ];;
    gap> y:= [ [ Z(2^2), Z(2)^0 ], [ 0*Z(2), Z(2^2)^2 ] ];;
    gap> res1:= ResultOfStraightLineProgram( progs[4][1], [ x, y ] );
    [ [ Z(2)^0, 0*Z(2) ], [ Z(2^2)^2, Z(2)^0 ] ]
    gap> res2:= ResultOfStraightLineProgram( progs[4][2], [ x, y ] );
    [ [ Z(2)^0, 0*Z(2) ], [ Z(2^2), Z(2)^0 ] ]
    gap> w:= y*x;;
    gap> res1 = w*y^-1*x*w*y^-1*x*y;
    true
    gap> subgrp:= Group( res1, res2 );;  Size( subgrp );  IsCyclic( subgrp );
    4
    false
  
  
  70.10-4 RepresentativeTom
  
  RepresentativeTom( tom, sub )  operation
  RepresentativeTomByGenerators( tom, sub, gens )  operation
  RepresentativeTomByGeneratorsNC( tom, sub, gens )  operation
  
  Let  tom  be  a  table  of marks with IsTableOfMarksWithGens (70.10-3) value
  true, and sub a positive integer. RepresentativeTom returns a representative
  of the sub-th conjugacy class of subgroups of tom.
  
  If  the  attribute  StraightLineProgramsTom  (70.10-2)  is  set  in tom then
  methods     for    the    operations    RepresentativeTomByGenerators    and
  RepresentativeTomByGeneratorsNC are available, which return a representative
  of  the  sub-th  conjugacy  class  of subgroups of tom, as a subgroup of the
  group  generated by gens. This means that the standard generators of tom are
  replaced by gens.
  
  RepresentativeTomByGenerators checks whether mapping the standard generators
  of  tom  to  gens  extends  to a group isomorphism, and returns fail if not.
  RepresentativeTomByGeneratorsNC       omits       all       checks.       So
  RepresentativeTomByGenerators is thought mainly for debugging purposes; note
  that  when  several  representatives  are  constructed,  it  is  cheaper  to
  construct  (and  check) the isomorphism once, and to map the groups returned
  by    RepresentativeTom    under   this   isomorphism.   The   idea   behind
  RepresentativeTomByGeneratorsNC,  however, is to avoid the overhead of using
  isomorphisms  when  gens  are  known  to be standard generators. In order to
  proceed  like  this,  the  attribute  StraightLineProgramsTom  (70.10-2)  is
  needed.
  
    Example  
    gap> RepresentativeTom( a5, 4 );
    Group([ (2,3)(4,5), (2,4)(3,5) ])
  
  
  
  70.11 The Interface between Tables of Marks and Character Tables
  
  The  following  examples  require  the  GAP  Character  Table  Library to be
  available. If it is not yet loaded then we load it now.
  
    Example  
    gap> LoadPackage( "ctbllib" );
    true
  
  
  70.11-1 FusionCharTableTom
  
  FusionCharTableTom( tbl, tom )  operation
  PossibleFusionsCharTableTom( tbl, tom[, options] )  operation
  
  Let  tbl  be  the  ordinary character table of the group G, say, and tom the
  table of marks of G. FusionCharTableTom determines the fusion of the classes
  of  elements  from tbl to the classes of cyclic subgroups on tom, that is, a
  list  that  contains  at  position  i  the  position  of the class of cyclic
  subgroups  in tom that are generated by elements in the i-th conjugacy class
  of elements in tbl.
  
  Three cases are handled differently.
  
  1   The  fusion  is explicitly stored on tbl. Then nothing has to be done.
        This  happens only if both tbl and tom are tables from the GAP library
        (see 70.13 and the manual of the GAP Character Table Library).
  
  2   The  UnderlyingGroup  (70.7-7)  values  of  tbl  and tom are known and
        equal. Then the group is used to compute the fusion.
  
  3   There  is neither fusion nor group information available. In this case
        only  necessary  conditions  can  be  checked,  and  if  they  are not
        sufficient  to  determine the fusion uniquely then fail is returned by
        FusionCharTableTom.
  
  PossibleFusionsCharTableTom  computes  the list of possible fusions from tbl
  to   tom,   according  to  the  criteria  that  have  been  checked.  So  if
  FusionCharTableTom  returns  a  unique  fusion  then  the  list  returned by
  PossibleFusionsCharTableTom  for  the  same  arguments contains exactly this
  fusion,  and if FusionCharTableTom returns fail then the length of this list
  is different from 1.
  
  The  optional  argument options must be a record that may have the following
  components.
  
  fusionmap
        a parametrized map which is an approximation of the desired map,
  
  quick
        a  Boolean;  if true then as soon as only one possibility remains this
        possibility is returned immediately; the default value is false.
  
    Example  
    gap> a5c:= CharacterTable( "A5" );;
    gap> fus:= FusionCharTableTom( a5c, a5 );
    [ 1, 2, 3, 5, 5 ]
  
  
  70.11-2 PermCharsTom
  
  PermCharsTom( fus, tom )  operation
  PermCharsTom( tbl, tom )  operation
  
  PermCharsTom  returns the list of transitive permutation characters from the
  table  of  marks tom. In the first form, fus must be the fusion map from the
  ordinary  character table of the group of tom to tom (see FusionCharTableTom
  (70.11-1)). In the second form, tbl must be the character table of the group
  of  which  tom  is  the  table  of  marks. If the fusion map is not uniquely
  determined (see FusionCharTableTom (70.11-1)) then fail is returned.
  
  If  the  fusion  map  fus  is  given  as first argument then each transitive
  permutation  character  is  represented by its values list. If the character
  table  tbl  is  given  then  the  permutation  characters are class function
  objects (see Chapter 72).
  
    Example  
    gap> PermCharsTom( a5c, a5 );
    [ Character( CharacterTable( "A5" ), [ 60, 0, 0, 0, 0 ] ), 
      Character( CharacterTable( "A5" ), [ 30, 2, 0, 0, 0 ] ), 
      Character( CharacterTable( "A5" ), [ 20, 0, 2, 0, 0 ] ), 
      Character( CharacterTable( "A5" ), [ 15, 3, 0, 0, 0 ] ), 
      Character( CharacterTable( "A5" ), [ 12, 0, 0, 2, 2 ] ), 
      Character( CharacterTable( "A5" ), [ 10, 2, 1, 0, 0 ] ), 
      Character( CharacterTable( "A5" ), [ 6, 2, 0, 1, 1 ] ), 
      Character( CharacterTable( "A5" ), [ 5, 1, 2, 0, 0 ] ), 
      Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ) ]
    gap> PermCharsTom( fus, a5 )[1];
    [ 60, 0, 0, 0, 0 ]
  
  
  
  70.12 Generic Construction of Tables of Marks
  
  The following three operations construct a table of marks only from the data
  given, i.e., without underlying group.
  
  70.12-1 TableOfMarksCyclic
  
  TableOfMarksCyclic( n )  operation
  
  TableOfMarksCyclic  returns  the table of marks of the cyclic group of order
  n.
  
  A  cyclic  group  of  order n has as its subgroups for each divisor d of n a
  cyclic subgroup of order d.
  
    Example  
    gap> Display( TableOfMarksCyclic( 6 ) );
    1:  6
    2:  3 3
    3:  2 . 2
    4:  1 1 1 1
    
  
  
  70.12-2 TableOfMarksDihedral
  
  TableOfMarksDihedral( n )  operation
  
  TableOfMarksDihedral  returns  the  table  of marks of the dihedral group of
  order m.
  
  For each divisor d of m, a dihedral group of order m = 2n contains subgroups
  of  order  d according to the following rule. If d is odd and divides n then
  there  is  only  one  cyclic subgroup of order d. If d is even and divides n
  then  there  are  a  cyclic  subgroup of order d and two classes of dihedral
  subgroups  of  order  d  (which  are cyclic, too, in the case d = 2, see the
  example  below).  Otherwise (i.e., if d does not divide n) there is just one
  class of dihedral subgroups of order d.
  
    Example  
    gap> Display( TableOfMarksDihedral( 12 ) );
     1:  12
     2:   6 6
     3:   6 . 2
     4:   6 . . 2
     5:   4 . . . 4
     6:   3 3 1 1 . 1
     7:   2 2 . . 2 . 2
     8:   2 . 2 . 2 . . 2
     9:   2 . . 2 2 . . . 2
    10:   1 1 1 1 1 1 1 1 1 1
    
  
  
  70.12-3 TableOfMarksFrobenius
  
  TableOfMarksFrobenius( p, q )  operation
  
  TableOfMarksFrobenius  computes  the  table of marks of a Frobenius group of
  order p q, where p is a prime and q divides p-1.
  
    Example  
    gap> Display( TableOfMarksFrobenius( 5, 4 ) );
    1:  20
    2:  10 2
    3:   5 1 1
    4:   4 . . 4
    5:   2 2 . 2 2
    6:   1 1 1 1 1 1
    
  
  
  
  70.13 The Library of Tables of Marks
  
  The GAP package TomLib provides access to several hundred tables of marks of
  almost  simple  groups  and  their  maximal  subgroups.  If  this package is
  installed   then   the  tables  from  this  database  can  be  accessed  via
  TableOfMarks  (70.3-1)  with  argument  a  string. If also the GAP Character
  Table  Library is installed and contains the ordinary character table of the
  group for which one wants to fetch the table of marks then one can also call
  TableOfMarks (70.3-1) with argument the character table.
  
  A  list  of  all  names  of  tables of marks that are provided by the TomLib
  package can be obtained via AllLibTomNames (TomLib: AllLibTomNames).
  
    Example  
    gap> names:= AllLibTomNames();;
    gap> "A5" in names;
    true