Welcome To Our Shell

Mister Spy & Souheyl Bypass Shell

  
  73 Maps Concerning Character Tables
  
  Besides  the  characters,  power  maps  are an important part of a character
  table,  see  Section 73.1.  Often  their computation is not easy, and if the
  table  has  no access to the underlying group then in general they cannot be
  obtained from the matrix of irreducible characters; so it is useful to store
  them on the table.
  
  If not only a single table is considered but different tables of a group and
  a subgroup or of a group and a factor group are used, also class fusion maps
  (see  Section 73.3)  must be known to get information about the embedding or
  simply to induce or restrict characters, see Section 72.9).
  
  These  are examples of functions from conjugacy classes which will be called
  maps  in  the following. (This should not be confused with the term mapping,
  cf. Chapter 32.) In GAP, maps are represented by lists. Also each character,
  each  list of element orders, of centralizer orders, or of class lengths are
  maps,  and  the  list  returned  by ListPerm (42.5-1), when this function is
  called with a permutation of classes, is a map.
  
  When  maps  are  constructed without access to a group, often one only knows
  that the image of a given class is contained in a set of possible images, e.
  g.,  that  the image of a class under a subgroup fusion is in the set of all
  classes  with  the  same  element  order. Using further information, such as
  centralizer  orders,  power maps and the restriction of characters, the sets
  of  possible images can be restricted further. In many cases, at the end the
  images are uniquely determined.
  
  Because  of this approach, many functions in this chapter work not only with
  maps  but  with  parametrized  maps  (or  paramaps  for  short).  More about
  parametrized maps can be found in Section 73.5.
  
  The implementation follows [Bre91], a description of the main ideas together
  with several examples can be found in [Bre99].
  
  Several  examples in this chapter require the GAP Character Table Library to
  be available. If it is not yet loaded then we load it now.
  
    Example  
    gap> LoadPackage( "ctbllib" );
    true
  
  
  
  73.1 Power Maps
  
  The n-th power map of a character table is represented by a list that stores
  at  position  i  the position of the class containing the n-th powers of the
  elements  in  the  i-th  class.  The n-th power map can be composed from the
  power maps of the prime divisors of n, so usually only power maps for primes
  are actually stored in the character table.
  
  For  an  ordinary character table tbl with access to its underlying group G,
  the  p-th  power  map of tbl can be computed using the identification of the
  conjugacy  classes  of  G with the classes of tbl. For an ordinary character
  table  without  access to a group, in general the p-th power maps (and hence
  also  the  element  orders)  for prime divisors p of the group order are not
  uniquely  determined  by  the  matrix  of  irreducible  characters.  So only
  necessary  conditions  can  be checked in this case, which in general yields
  only  a  list  of several possibilities for the desired power map. Character
  tables  of  the  GAP  character  table library store all p-th power maps for
  prime divisors p of the group order.
  
  Power  maps  of  Brauer  tables  can  be  derived from the power maps of the
  underlying ordinary tables.
  
  For  (computing  and)  accessing  the  n-th  power map of a character table,
  PowerMap  (73.1-1)  can  be  used;  if the n-th power map cannot be uniquely
  determined then PowerMap (73.1-1) returns fail.
  
  The  list  of  all  possible  p-th  power  maps of a table in the sense that
  certain   necessary   conditions   are   satisfied   can  be  computed  with
  PossiblePowerMaps   (73.1-2).   This   provides   a  default  strategy,  the
  subroutines are listed in Section 73.6.
  
  73.1-1 PowerMap
  
  PowerMap( tbl, n[, class] )  operation
  PowerMapOp( tbl, n[, class] )  operation
  ComputedPowerMaps( tbl )  attribute
  
  Called  with  first  argument  a  character table tbl and second argument an
  integer  n,  PowerMap  returns  the  n-th  power  map of tbl. This is a list
  containing  at  position  i  the position of the class of n-th powers of the
  elements in the i-th class of tbl.
  
  If  the additional third argument class is present then the position of n-th
  powers of the class-th class is returned.
  
  If  the  n-th  power  map  is  not  uniquely  determined by tbl then fail is
  returned. This can happen only if tbl has no access to its underlying group.
  
  The  power  maps of tbl that were computed already by PowerMap are stored in
  tbl  as  value  of  the  attribute  ComputedPowerMaps, the n-th power map at
  position n. PowerMap checks whether the desired power map is already stored,
  computes  it  using  the  operation  PowerMapOp  if it is not yet known, and
  stores it. So methods for the computation of power maps can be installed for
  the operation PowerMapOp.
  
    Example  
    gap> tbl:= CharacterTable( "L3(2)" );;
    gap> ComputedPowerMaps( tbl );
    [ , [ 1, 1, 3, 2, 5, 6 ], [ 1, 2, 1, 4, 6, 5 ],,,, 
      [ 1, 2, 3, 4, 1, 1 ] ]
    gap> PowerMap( tbl, 5 );
    [ 1, 2, 3, 4, 6, 5 ]
    gap> ComputedPowerMaps( tbl );
    [ , [ 1, 1, 3, 2, 5, 6 ], [ 1, 2, 1, 4, 6, 5 ],, [ 1, 2, 3, 4, 6, 5 ],
      , [ 1, 2, 3, 4, 1, 1 ] ]
    gap> PowerMap( tbl, 137, 2 );
    2
  
  
  73.1-2 PossiblePowerMaps
  
  PossiblePowerMaps( tbl, p[, options] )  operation
  
  For  the  ordinary  character  table  tbl  of  the group G, say, and a prime
  integer  p,  PossiblePowerMaps  returns  the  list of all maps that have the
  following  properties  of  the p-th power map of tbl. (Representative orders
  are  used  only  if  the OrdersClassRepresentatives (71.9-1) value of tbl is
  known.
  
  1   For  class  i, the centralizer order of the image is a multiple of the
        i-th  centralizer  order; if the elements in the i-th class have order
        coprime  to p then the centralizer orders of class i and its image are
        equal.
  
  2   Let n be the order of elements in class i. If prime divides n then the
        images  have  order  n/p;  otherwise  the  images  have order n. These
        criteria are checked in InitPowerMap (73.6-1).
  
  3   For  each  character χ of G and each element g in G, the values χ(g^p)
        and  GaloisCyc(  χ(g),  p  ) are algebraic integers that are congruent
        modulo  p;  if  p  does not divide the element order of g then the two
        values  are  equal.  This  congruence  is  checked  for the characters
        specified  below in the discussion of the options argument; For linear
        characters  λ among these characters, the condition χ(g)^p = χ(g^p) is
        checked. The corresponding function is Congruences (73.6-2).
  
  4   For  each character χ of G, the kernel is a normal subgroup N, and g^p
        ∈  N  for  all g ∈ N; moreover, if N has index p in G then g^p ∈ N for
        all g ∈ G, and if the index of N in G is coprime to p then g^p not ∈ N
        for  each  g  not ∈ N. These conditions are checked for the kernels of
        all  characters  χ  specified  below,  the  corresponding  function is
        ConsiderKernels (73.6-3).
  
  5   If  p is larger than the order m of an element g ∈ G then the class of
        g^p is determined by the power maps for primes dividing the residue of
        p  modulo  m.  If these power maps are stored in the ComputedPowerMaps
        (73.1-1) value of tbl then this information is used. This criterion is
        checked in ConsiderSmallerPowerMaps (73.6-4).
  
  6   For  each  character  χ  of  G, the symmetrization ψ defined by ψ(g) =
        (χ(g)^p  - χ(g^p))/p is a character. This condition is checked for the
        kernels  of  all  characters  χ  specified  below,  the  corresponding
        function is PowerMapsAllowedBySymmetrizations (73.6-6).
  
  If  tbl is a Brauer table, the possibilities are computed from those for the
  underlying ordinary table.
  
  The  optional argument options, if given, must be a record that may have the
  following components:
  
  chars:
        a  list of characters which are used for the check of the criteria 3.,
        4., and 6.; the default is Irr( tbl ),
  
  powermap:
        a parametrized map which is an approximation of the desired map
  
  decompose:
        a  Boolean;  a  true  value  indicates  that  all  constituents of the
        symmetrizations  of  chars  computed for criterion 6. lie in chars, so
        the  symmetrizations  can  be  decomposed  into elements of chars; the
        default  value of decompose is true if chars is not bound and Irr( tbl
        ) is known, otherwise false,
  
  quick:
        a Boolean; if true then the subroutines are called with value true for
        the  argument quick; especially, as soon as only one candidate remains
        this candidate is returned immediately; the default value is false,
  
  parameters:
        a  record  with components maxamb, minamb and maxlen which control the
        subroutine  PowerMapsAllowedBySymmetrizations  (73.6-6);  it only uses
        characters   with   current  indeterminateness  up  to  maxamb,  tests
        decomposability  only for characters with current indeterminateness at
        least  minamb,  and  admits  a branch according to a character only if
        there is one with at most maxlen possible symmetrizations.
  
    Example  
    gap> tbl:= CharacterTable( "U4(3).4" );;
    gap> PossiblePowerMaps( tbl, 2 );
    [ [ 1, 1, 3, 4, 5, 2, 2, 8, 3, 4, 11, 12, 6, 14, 9, 1, 1, 2, 2, 3, 4, 
          5, 6, 8, 9, 9, 10, 11, 12, 16, 16, 16, 16, 17, 17, 18, 18, 18, 
          18, 20, 20, 20, 20, 22, 22, 24, 24, 25, 26, 28, 28, 29, 29 ] ]
  
  
  73.1-3 ElementOrdersPowerMap
  
  ElementOrdersPowerMap( powermap )  function
  
  Let powermap be a nonempty list containing at position p, if bound, the p-th
  power  map  of  a  character table or group. ElementOrdersPowerMap returns a
  list  of the same length as each entry in powermap, with entry at position i
  equal  to  the  order  of  elements  in  class  i  if this order is uniquely
  determined by powermap, and equal to an unknown (see Chapter 74) otherwise.
  
    Example  
    gap> tbl:= CharacterTable( "U4(3).4" );;
    gap> known:= ComputedPowerMaps( tbl );;
    gap> Length( known );
    7
    gap> sub:= ShallowCopy( known );;  Unbind( sub[7] );
    gap> ElementOrdersPowerMap( sub );
    [ 1, 2, 3, 3, 3, 4, 4, 5, 6, 6, Unknown(1), Unknown(2), 8, 9, 12, 2, 
      2, 4, 4, 6, 6, 6, 8, 10, 12, 12, 12, Unknown(3), Unknown(4), 4, 4, 
      4, 4, 4, 4, 8, 8, 8, 8, 12, 12, 12, 12, 12, 12, 20, 20, 24, 24, 
      Unknown(5), Unknown(6), Unknown(7), Unknown(8) ]
    gap> ord:= ElementOrdersPowerMap( known );
    [ 1, 2, 3, 3, 3, 4, 4, 5, 6, 6, 7, 7, 8, 9, 12, 2, 2, 4, 4, 6, 6, 6, 
      8, 10, 12, 12, 12, 14, 14, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 12, 12, 
      12, 12, 12, 12, 20, 20, 24, 24, 28, 28, 28, 28 ]
    gap> ord = OrdersClassRepresentatives( tbl );
    true
  
  
  73.1-4 PowerMapByComposition
  
  PowerMapByComposition( tbl, n )  function
  
  tbl must be a nearly character table, and n a positive integer. If the power
  maps  for  all  prime  divisors  of  n  are  stored in the ComputedPowerMaps
  (73.1-1)  list  of tbl then PowerMapByComposition returns the n-th power map
  of tbl. Otherwise fail is returned.
  
    Example  
    gap> tbl:= CharacterTable( "U4(3).4" );;  exp:= Exponent( tbl );
    2520
    gap> PowerMapByComposition( tbl, exp );
    [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
      1, 1, 1, 1, 1, 1, 1, 1, 1 ]
    gap> Length( ComputedPowerMaps( tbl ) );
    7
    gap> PowerMapByComposition( tbl, 11 );
    fail
    gap> PowerMap( tbl, 11 );;
    gap> PowerMapByComposition( tbl, 11 );
    [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 
      20, 21, 22, 23, 24, 26, 25, 27, 28, 29, 31, 30, 33, 32, 35, 34, 37, 
      36, 39, 38, 41, 40, 43, 42, 45, 44, 47, 46, 49, 48, 51, 50, 53, 52 ]
  
  
  
  73.2 Orbits on Sets of Possible Power Maps
  
  The  permutation  group  of  matrix  automorphisms  (see MatrixAutomorphisms
  (71.22-1))  acts  on  the  possible power maps returned by PossiblePowerMaps
  (73.1-2)  by  permuting  a list via Permuted (21.20-18) and then mapping the
  images  via  OnPoints  (41.2-1). Note that by definition, the group of table
  automorphisms acts trivially.
  
  73.2-1 OrbitPowerMaps
  
  OrbitPowerMaps( map, permgrp )  function
  
  returns  the  orbit of the power map map under the action of the permutation
  group  permgrp  via  a  combination  of  Permuted  (21.20-18)  and  OnPoints
  (41.2-1).
  
  73.2-2 RepresentativesPowerMaps
  
  RepresentativesPowerMaps( listofmaps, permgrp )  function
  
  returns  a  list  of  orbit  representatives  of  the power maps in the list
  listofmaps  under  the  action  of  the  permutation  group  permgrp  via  a
  combination of Permuted (21.20-18) and OnPoints (41.2-1).
  
    Example  
    gap> tbl:= CharacterTable( "3.McL" );;
    gap> grp:= MatrixAutomorphisms( Irr( tbl ) );  Size( grp );
    <permutation group with 5 generators>
    32
    gap> poss:= PossiblePowerMaps( CharacterTable( "3.McL" ), 3 );
    [ [ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17, 
          4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, 9, 8, 37, 
          37, 37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 52, 49, 49, 
          49, 14, 14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ], 
      [ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17, 
          4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, 8, 9, 37, 
          37, 37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 52, 49, 49, 
          49, 14, 14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ] ]
    gap> reps:= RepresentativesPowerMaps( poss, grp );
    [ [ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17, 
          4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, 8, 9, 37, 
          37, 37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 52, 49, 49, 
          49, 14, 14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ] ]
    gap> orb:= OrbitPowerMaps( reps[1], grp );
    [ [ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17, 
          4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, 8, 9, 37, 
          37, 37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 52, 49, 49, 
          49, 14, 14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ], 
      [ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17, 
          4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, 9, 8, 37, 
          37, 37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 52, 49, 49, 
          49, 14, 14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ] ]
    gap> Parametrized( orb );
    [ 1, 1, 1, 4, 4, 4, 1, 1, 1, 1, 11, 11, 11, 14, 14, 14, 17, 17, 17, 
      4, 4, 4, 4, 4, 4, 29, 29, 29, 26, 26, 26, 32, 32, 32, [ 8, 9 ], 
      [ 8, 9 ], 37, 37, 37, 40, 40, 40, 43, 43, 43, 11, 11, 11, 52, 52, 
      52, 49, 49, 49, 14, 14, 14, 14, 14, 14, 37, 37, 37, 37, 37, 37 ]
  
  
  
  73.3 Class Fusions between Character Tables
  
  For  a  group  G and a subgroup H of G, the fusion map between the character
  table of H and the character table of G is represented by a list that stores
  at  position  i  the  position  of  the  i-th class of the table of H in the
  classes list of the table of G.
  
  For  ordinary  character tables tbl1 and tbl2 of H and G, with access to the
  groups H and G, the class fusion between tbl1 and tbl2 can be computed using
  the  identifications  of the conjugacy classes of H with the classes of tbl1
  and  the  conjugacy  classes of G with the classes of tbl2. For two ordinary
  character  tables without access to an underlying group, or in the situation
  that  the  group  stored  in  tbl1 is not physically a subgroup of the group
  stored  in  tbl2  but an isomorphic copy, in general the class fusion is not
  uniquely  determined  by  the  information  stored  on  the  tables  such as
  irreducible  characters  and power maps. So only necessary conditions can be
  checked  in  this  case,  which  in  general  yields  only a list of several
  possibilities  for  the  desired  class  fusion. Character tables of the GAP
  character  table  library  store  various class fusions that are regarded as
  important,     for     example     fusions     from     maximal    subgroups
  (see ComputedClassFusions  (73.3-2) and Maxes (CTblLib: Maxes) in the manual
  for the GAP Character Table Library).
  
  Class  fusions  between  Brauer tables can be derived from the class fusions
  between the underlying ordinary tables. The class fusion from a Brauer table
  to  the  underlying  ordinary  table  is  stored  when  the  Brauer table is
  constructed  from the ordinary table, so no method is needed to compute such
  a fusion.
  
  For (computing and) accessing the class fusion between two character tables,
  FusionConjugacyClasses  (73.3-1)  can be used; if the class fusion cannot be
  uniquely determined then FusionConjugacyClasses (73.3-1) returns fail.
  
  The  list  of all possible class fusion between two tables in the sense that
  certain   necessary   conditions   are   satisfied   can  be  computed  with
  PossibleClassFusions   (73.3-6).  This  provides  a  default  strategy,  the
  subroutines are listed in Section 73.7.
  
  It   should   be   noted   that   all   the   following   functions   except
  FusionConjugacyClasses  (73.3-1)  deal  only  with  the  situation  of class
  fusions  from  subgroups. The computation of factor fusions from a character
  table  to  the  table  of  a  factor group is not dealt with here. Since the
  ordinary character table of a group G determines the character tables of all
  factor groups of G, the factor fusion to a given character table of a factor
  group of G is determined up to table automorphisms (see AutomorphismsOfTable
  (71.9-4))  once the class positions of the kernel of the natural epimorphism
  have been fixed.
  
  
  73.3-1 FusionConjugacyClasses
  
  FusionConjugacyClasses( tbl1, tbl2 )  operation
  FusionConjugacyClasses( H, G )  operation
  FusionConjugacyClasses( hom[, tbl1, tbl2] )  operation
  FusionConjugacyClassesOp( tbl1, tbl2 )  operation
  FusionConjugacyClassesOp( hom )  attribute
  
  Called  with  two  character  tables  tbl1  and tbl2, FusionConjugacyClasses
  returns  the  fusion  of conjugacy classes between tbl1 and tbl2. (If one of
  the  tables  is a Brauer table, it will delegate this task to the underlying
  ordinary table.)
  
  Called   with   two   groups   H   and  G  where  H  is  a  subgroup  of  G,
  FusionConjugacyClasses returns the fusion of conjugacy classes between H and
  G.  This  is done by delegating to the ordinary character tables of H and G,
  since class fusions are stored only for character tables and not for groups.
  
  Note  that  the  returned  class  fusion refers to the ordering of conjugacy
  classes in the character tables if the arguments are character tables and to
  the  ordering of conjugacy classes in the groups if the arguments are groups
  (see ConjugacyClasses (71.6-2)).
  
  Called  with  a  group  homomorphism hom, FusionConjugacyClasses returns the
  fusion  of  conjugacy  classes  between  the  preimage and the image of hom;
  contrary  to the two cases above, also factor fusions can be handled by this
  variant.  If  hom  is  the only argument then the class fusion refers to the
  ordering  of  conjugacy  classes  in  the groups. If the character tables of
  preimage and image are given as tbl1 and tbl2, respectively (each table with
  its  group  stored),  then  the  fusion refers to the ordering of classes in
  these tables.
  
  If no class fusion exists or if the class fusion is not uniquely determined,
  fail is returned; this may happen when FusionConjugacyClasses is called with
  two character tables that do not know compatible underlying groups.
  
  Methods  for  the  computation  of  class  fusions  can be installed for the
  operation FusionConjugacyClassesOp.
  
    Example  
    gap> s4:= SymmetricGroup( 4 );
    Sym( [ 1 .. 4 ] )
    gap> tbls4:= CharacterTable( s4 );;
    gap> d8:= SylowSubgroup( s4, 2 );
    Group([ (1,2), (3,4), (1,3)(2,4) ])
    gap> FusionConjugacyClasses( d8, s4 );
    [ 1, 2, 3, 3, 5 ]
    gap> tbls5:= CharacterTable( "S5" );;
    gap> FusionConjugacyClasses( CharacterTable( "A5" ), tbls5 );
    [ 1, 2, 3, 4, 4 ]
    gap> FusionConjugacyClasses(CharacterTable("A5"), CharacterTable("J1"));
    fail
    gap> PossibleClassFusions(CharacterTable("A5"), CharacterTable("J1"));
    [ [ 1, 2, 3, 4, 5 ], [ 1, 2, 3, 5, 4 ] ]
  
  
  73.3-2 ComputedClassFusions
  
  ComputedClassFusions( tbl )  attribute
  
  The  class  fusions  from  the  character  table tbl that have been computed
  already   by   FusionConjugacyClasses   (73.3-1)  or  explicitly  stored  by
  StoreFusion  (73.3-4)  are  stored in the ComputedClassFusions list of tbl1.
  Each entry of this list is a record with the following components.
  
  name
        the  Identifier  (71.9-8)  value  of  the character table to which the
        fusion maps,
  
  map
        the list of positions of image classes,
  
  text (optional)
        a  string  giving  additional  information  about  the fusion map, for
        example  whether  the  map  is  uniquely  determined  by the character
        tables,
  
  specification (optional, rarely used)
        a value that distinguishes different fusions between the same tables.
  
  Note  that  stored  fusion  maps  may  differ  from  the  maps  returned  by
  GetFusionMap  (73.3-3)  and  the maps entered by StoreFusion (73.3-4) if the
  table  destination has a nonidentity ClassPermutation (71.21-5) value. So if
  one fetches a fusion map from a table tbl1 to a table tbl2 via access to the
  data  in the ComputedClassFusions list of tbl1 then the stored value must be
  composed  with  the  ClassPermutation  (71.21-5)  value  of tbl2 in order to
  obtain   the  correct  class  fusion.  (If  one  handles  fusions  only  via
  GetFusionMap  (73.3-3) and StoreFusion (73.3-4) then this adjustment is made
  automatically.)
  
  Fusions  are identified via the Identifier (71.9-8) value of the destination
  table  and  not  by this table itself because many fusions between character
  tables  in the GAP character table library are stored on library tables, and
  it  is  not  desirable  to load together with a library table also all those
  character tables that occur as destinations of fusions from this table.
  
  For  storing  fusions  and  accessing  stored fusions, see also GetFusionMap
  (73.3-3), StoreFusion (73.3-4). For accessing the identifiers of tables that
  store  a  fusion  into  a  given  character  table, see NamesOfFusionSources
  (73.3-5).
  
  73.3-3 GetFusionMap
  
  GetFusionMap( source, destination[, specification] )  function
  
  For  two  ordinary  character  tables  source  and destination, GetFusionMap
  checks  whether  the ComputedClassFusions (73.3-2) list of source contains a
  record  with  name  component Identifier( destination ), and returns returns
  the   map   component  of  the  first  such  record.  GetFusionMap(  source,
  destination,  specification  )  fetches that fusion map for which the record
  additionally has the specification component specification.
  
  If  both  source  and destination are Brauer tables, first the same is done,
  and  if no fusion map was found then GetFusionMap looks whether a fusion map
  between  the  ordinary  tables  is stored; if so then the fusion map between
  source and destination is stored on source, and then returned.
  
  If  no  appropriate  fusion  is  found,  GetFusionMap  returns fail. For the
  computation of class fusions, see FusionConjugacyClasses (73.3-1).
  
  73.3-4 StoreFusion
  
  StoreFusion( source, fusion, destination )  function
  
  For  two  character  tables  source  and destination, StoreFusion stores the
  fusion  fusion  from  source  to  destination  in  the  ComputedClassFusions
  (73.3-2)  list  of  source,  and  adds  the  Identifier  (71.9-8)  string of
  destination to the NamesOfFusionSources (73.3-5) list of destination.
  
  fusion  can  either  be  a fusion map (that is, the list of positions of the
  image classes) or a record as described in ComputedClassFusions (73.3-2).
  
  If  fusions  to destination are already stored on source then another fusion
  can  be  stored  only  if  it  has  a  record  component  specification that
  distinguishes  it from the stored fusions. In the case of such an ambiguity,
  StoreFusion raises an error.
  
    Example  
    gap> tbld8:= CharacterTable( d8 );;
    gap> ComputedClassFusions( tbld8 );
    [ rec( map := [ 1, 2, 3, 3, 5 ], name := "CT1" ) ]
    gap> Identifier( tbls4 );
    "CT1"
    gap> GetFusionMap( tbld8, tbls4 );
    [ 1, 2, 3, 3, 5 ]
    gap> GetFusionMap( tbls4, tbls5 );
    fail
    gap> poss:= PossibleClassFusions( tbls4, tbls5 );
    [ [ 1, 5, 2, 3, 6 ] ]
    gap> StoreFusion( tbls4, poss[1], tbls5 );
    gap> GetFusionMap( tbls4, tbls5 );
    [ 1, 5, 2, 3, 6 ]
  
  
  73.3-5 NamesOfFusionSources
  
  NamesOfFusionSources( tbl )  attribute
  
  For  a  character  table  tbl,  NamesOfFusionSources  returns  the  list  of
  identifiers  of all those character tables that are known to have fusions to
  tbl  stored.  The NamesOfFusionSources value is updated whenever a fusion to
  tbl is stored using StoreFusion (73.3-4).
  
    Example  
    gap> NamesOfFusionSources( tbls4 );
    [ "CT2" ]
    gap> Identifier( CharacterTable( d8 ) );
    "CT2"
  
  
  73.3-6 PossibleClassFusions
  
  PossibleClassFusions( subtbl, tbl[, options] )  operation
  
  For two ordinary character tables subtbl and tbl of the groups H and G, say,
  PossibleClassFusions  returns  the  list of all maps that have the following
  properties of class fusions from subtbl to tbl.
  
  1   For  class i, the centralizer order of the image in G is a multiple of
        the  i-th  centralizer  order in H, and the element orders in the i-th
        class  and  its  image  are  equal.  These  criteria  are  checked  in
        InitFusion (73.7-1).
  
  2   The  class  fusion  commutes  with  power  maps. This is checked using
        TestConsistencyMaps (73.5-12).
  
  3   If  the permutation character of G corresponding to the action of G on
        the  cosets  of  H  is  specified  (see  the discussion of the options
        argument below) then it prescribes for each class C of G the number of
        elements   of   H   fusing  into  C.  The  corresponding  function  is
        CheckPermChar (73.7-2).
  
  4   The table automorphisms of tbl (see AutomorphismsOfTable (71.9-4)) are
        used  in  order  to compute only orbit representatives. (But note that
        the list returned by PossibleClassFusions contains the full orbits.)
  
  5   For  each  character χ of G, the restriction to H via the class fusion
        is  a  character  of  H.  This condition is checked for all characters
        specified      below,      the      corresponding      function     is
        FusionsAllowedByRestrictions (73.7-4).
  
  6   The  class  multiplication  coefficients  in  subtbl do not exceed the
        corresponding    coefficients    in    tbl.   This   is   checked   in
        ConsiderStructureConstants  (73.3-7),  see  also  the  comment  on the
        parameter verify below.
  
  If subtbl and tbl are Brauer tables then the possibilities are computed from
  those for the underlying ordinary tables.
  
  The  optional  argument options must be a record that may have the following
  components:
  
  chars
        a  list  of  characters of tbl which are used for the check of 5.; the
        default is Irr( tbl ),
  
  subchars
        a  list  of  characters  of  subtbl  which  are  constituents  of  the
        restrictions of chars, the default is Irr( subtbl ),
  
  fusionmap
        a parametrized map which is an approximation of the desired map,
  
  decompose
        a  Boolean;  a  true  value  indicates  that  all  constituents of the
        restrictions  of  chars  computed for criterion 5. lie in subchars, so
        the  restrictions  can  be  decomposed  into elements of subchars; the
        default  value  of decompose is true if subchars is not bound and Irr(
        subtbl ) is known, otherwise false,
  
  permchar
        (a  values  list  of)  a  permutation  character;  only  those fusions
        affording that permutation character are computed,
  
  quick
        a Boolean; if true then the subroutines are called with value true for
        the  argument  quick;  especially,  as  soon  as  only one possibility
        remains  then  this  possibility  is returned immediately; the default
        value is false,
  
  verify
        a Boolean; if false then ConsiderStructureConstants (73.3-7) is called
        only  if  more  than one orbit of possible class fusions exists, under
        the  action of the groups of table automorphisms; the default value is
        false  (because  the computation of the structure constants is usually
        very time consuming, compared with checking the other criteria),
  
  parameters
        a  record  with components maxamb, minamb and maxlen (and perhaps some
        optional      components)     which     control     the     subroutine
        FusionsAllowedByRestrictions  (73.7-4);  it  only uses characters with
        current indeterminateness up to maxamb, tests decomposability only for
        characters  with current indeterminateness at least minamb, and admits
        a  branch  according  to a character only if there is one with at most
        maxlen possible restrictions.
  
    Example  
    gap> subtbl:= CharacterTable( "U3(3)" );;  tbl:= CharacterTable( "J4" );;
    gap> PossibleClassFusions( subtbl, tbl );
    [ [ 1, 2, 4, 4, 5, 5, 6, 10, 12, 13, 14, 14, 21, 21 ], 
      [ 1, 2, 4, 4, 5, 5, 6, 10, 13, 12, 14, 14, 21, 21 ], 
      [ 1, 2, 4, 4, 6, 6, 6, 10, 12, 13, 15, 15, 22, 22 ], 
      [ 1, 2, 4, 4, 6, 6, 6, 10, 12, 13, 16, 16, 22, 22 ], 
      [ 1, 2, 4, 4, 6, 6, 6, 10, 13, 12, 15, 15, 22, 22 ], 
      [ 1, 2, 4, 4, 6, 6, 6, 10, 13, 12, 16, 16, 22, 22 ] ]
  
  
  73.3-7 ConsiderStructureConstants
  
  ConsiderStructureConstants( subtbl, tbl, fusions, quick )  function
  
  Let  subtbl  and  tbl  be ordinary character tables and fusions be a list of
  possible  class  fusions  from  subtbl  to  tbl.  ConsiderStructureConstants
  returns  the  list of those maps σ in fusions with the property that for all
  triples  (i,j,k) of class positions, ClassMultiplicationCoefficient( subtbl,
  i,  j,  k  )  is  not bigger than ClassMultiplicationCoefficient( tbl, σ[i],
  σ[j],   σ[k]   );   see ClassMultiplicationCoefficient   (71.12-7)  for  the
  definition of class multiplication coefficients/structure constants.
  
  The  argument quick must be a Boolean; if it is true then only those triples
  are  checked  for  which  for  which  at  least  two entries in fusions have
  different images.
  
  
  73.4 Orbits on Sets of Possible Class Fusions
  
  The  permutation  groups  of  table  automorphisms (see AutomorphismsOfTable
  (71.9-4))  of  the subgroup table subtbl and the supergroup table tbl act on
  the  possible  class  fusions  from  subtbl  to  tbl  that  are  returned by
  PossibleClassFusions  (73.3-6),  the former by permuting a list via Permuted
  (21.20-18), the latter by mapping the images via OnPoints (41.2-1).
  
  If  a  set of possible fusions with certain properties was computed that are
  not  invariant  under  the  full  groups  of table automorphisms then only a
  smaller group acts on this set. This may happen for example if a permutation
  character  or  if an explicit approximation of the fusion map was prescribed
  in the call of PossibleClassFusions (73.3-6).
  
  73.4-1 OrbitFusions
  
  OrbitFusions( subtblautomorphisms, fusionmap, tblautomorphisms )  function
  
  returns the orbit of the class fusion map fusionmap under the actions of the
  permutation groups subtblautomorphisms and tblautomorphisms of automorphisms
  of the character table of the subgroup and the supergroup, respectively.
  
  73.4-2 RepresentativesFusions
  
  RepresentativesFusions( subtbl, listofmaps, tbl )  function
  
  Let listofmaps be a list of class fusions from the character table subtbl to
  the  character  table  tbl.  RepresentativesFusions  returns a list of orbit
  representatives  of the class fusions under the action of maximal admissible
  subgroups of the table automorphism groups of these character tables.
  
  Instead  of the character tables subtbl and tbl, also the permutation groups
  of  their  table  automorphisms  (see  AutomorphismsOfTable (71.9-4)) may be
  entered.
  
    Example  
    gap> fus:= GetFusionMap( subtbl, tbl );
    [ 1, 2, 4, 4, 5, 5, 6, 10, 12, 13, 14, 14, 21, 21 ]
    gap> orb:= OrbitFusions( AutomorphismsOfTable( subtbl ), fus,
    >              AutomorphismsOfTable( tbl ) );
    [ [ 1, 2, 4, 4, 5, 5, 6, 10, 12, 13, 14, 14, 21, 21 ], 
      [ 1, 2, 4, 4, 5, 5, 6, 10, 13, 12, 14, 14, 21, 21 ] ]
    gap> rep:= RepresentativesFusions( subtbl, orb, tbl );
    [ [ 1, 2, 4, 4, 5, 5, 6, 10, 12, 13, 14, 14, 21, 21 ] ]
  
  
  
  73.5 Parametrized Maps
  
  A parametrized map is a list whose i-th entry is either unbound (which means
  that  nothing is known about the image(s) of the i-th class) or the image of
  the i-th class (i.e., an integer for fusion maps, power maps, element orders
  etc.,  and a cyclotomic for characters), or a list of possible images of the
  i-th  class.  In  this  sense,  maps are special parametrized maps. We often
  identify  a  parametrized  map paramap with the set of all maps map with the
  property  that either map[i] = paramap[i] or map[i] is contained in the list
  paramap[i]; we say then that map is contained in paramap.
  
  This  definition  implies  that parametrized maps cannot be used to describe
  sets of maps where lists are possible images. An exception are strings which
  naturally  arise  as  images when class names are considered. So strings and
  lists  of  strings are allowed in parametrized maps, and character constants
  (see Chapter 27) are not allowed in maps.
  
  73.5-1 CompositionMaps
  
  CompositionMaps( paramap2, paramap1[, class] )  function
  
  The  composition  of  two parametrized maps paramap1, paramap2 is defined as
  the  parametrized  map  comp  that  contains  all  compositions f_2 ∘ f_1 of
  elements  f_1  of paramap1 and f_2 of paramap2. For example, the composition
  of  a  character  χ  of  a group G by a parametrized class fusion map from a
  subgroup  H to G is the parametrized map that contains all restrictions of χ
  by elements of the parametrized fusion map.
  
  CompositionMaps(paramap2,   paramap1)  is  a  parametrized  map  with  entry
  CompositionMaps(paramap2,   paramap1,   class)   at   position   class.   If
  paramap1[class]  is  an  integer  then  CompositionMaps(paramap2,  paramap1,
  class)  is equal to paramap2[ paramap1[ class ] ]. Otherwise it is the union
  of paramap2[i] for i in paramap1[ class ].
  
    Example  
    gap> map1:= [ 1, [ 2 .. 4 ], [ 4, 5 ], 1 ];;
    gap> map2:= [ [ 1, 2 ], 2, 2, 3, 3 ];;
    gap> CompositionMaps( map2, map1 );
    [ [ 1, 2 ], [ 2, 3 ], 3, [ 1, 2 ] ]
    gap> CompositionMaps( map1, map2 );
    [ [ 1, 2, 3, 4 ], [ 2, 3, 4 ], [ 2, 3, 4 ], [ 4, 5 ], [ 4, 5 ] ]
  
  
  73.5-2 InverseMap
  
  InverseMap( paramap )  function
  
  For  a  parametrized  map paramap, InverseMap returns a mutable parametrized
  map  whose  i-th entry is unbound if i is not in the image of paramap, equal
  to  j  if  i is (in) the image of paramap[j] exactly for j, and equal to the
  set of all preimages of i under paramap otherwise.
  
  We have CompositionMaps( paramap, InverseMap( paramap ) ) the identity map.
  
    Example  
    gap> tbl:= CharacterTable( "2.A5" );;  f:= CharacterTable( "A5" );;
    gap> fus:= GetFusionMap( tbl, f );
    [ 1, 1, 2, 3, 3, 4, 4, 5, 5 ]
    gap> inv:= InverseMap( fus );
    [ [ 1, 2 ], 3, [ 4, 5 ], [ 6, 7 ], [ 8, 9 ] ]
    gap> CompositionMaps( fus, inv );
    [ 1, 2, 3, 4, 5 ]
    gap> # transfer a power map ``up'' to the factor group
    gap> pow:= PowerMap( tbl, 2 );
    [ 1, 1, 2, 4, 4, 8, 8, 6, 6 ]
    gap> CompositionMaps( fus, CompositionMaps( pow, inv ) );
    [ 1, 1, 3, 5, 4 ]
    gap> last = PowerMap( f, 2 );
    true
    gap> # transfer a power map of the factor group ``down'' to the group
    gap> CompositionMaps( inv, CompositionMaps( PowerMap( f, 2 ), fus ) );
    [ [ 1, 2 ], [ 1, 2 ], [ 1, 2 ], [ 4, 5 ], [ 4, 5 ], [ 8, 9 ], 
      [ 8, 9 ], [ 6, 7 ], [ 6, 7 ] ]
  
  
  73.5-3 ProjectionMap
  
  ProjectionMap( fusionmap )  function
  
  For  a  map  fusionmap,  ProjectionMap returns a parametrized map whose i-th
  entry  is unbound if i is not in the image of fusionmap, and equal to j if j
  is the smallest position such that i is the image of fusionmap[j].
  
  We  have  CompositionMaps(  fusionmap,  ProjectionMap(  fusionmap  )  )  the
  identity  map,  i.e.,  first projecting and then fusing yields the identity.
  Note that fusionmap must not be a parametrized map.
  
    Example  
    gap> ProjectionMap( [ 1, 1, 1, 2, 2, 2, 3, 4, 5, 5, 5, 6, 6, 6 ] );
    [ 1, 4, 7, 8, 9, 12 ]
  
  
  73.5-4 Indirected
  
  Indirected( character, paramap )  function
  
  For  a  map  character  and a parametrized map paramap, Indirected returns a
  parametrized  map  whose  entry  at position i is character[ paramap[i] ] if
  paramap[i] is an integer, and an unknown (see Chapter 74) otherwise.
  
    Example  
    gap> tbl:= CharacterTable( "M12" );;
    gap> fus:= [ 1, 3, 4, [ 6, 7 ], 8, 10, [ 11, 12 ], [ 11, 12 ],
    >            [ 14, 15 ], [ 14, 15 ] ];;
    gap> List( Irr( tbl ){ [ 1 .. 6 ] }, x -> Indirected( x, fus ) );
    [ [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ], 
      [ 11, 3, 2, Unknown(9), 1, 0, Unknown(10), Unknown(11), 0, 0 ], 
      [ 11, 3, 2, Unknown(12), 1, 0, Unknown(13), Unknown(14), 0, 0 ], 
      [ 16, 0, -2, 0, 1, 0, 0, 0, Unknown(15), Unknown(16) ], 
      [ 16, 0, -2, 0, 1, 0, 0, 0, Unknown(17), Unknown(18) ], 
      [ 45, -3, 0, 1, 0, 0, -1, -1, 1, 1 ] ]
  
  
  73.5-5 Parametrized
  
  Parametrized( list )  function
  
  For  a  list  list  of  (parametrized) maps of the same length, Parametrized
  returns the smallest parametrized map containing all elements of list.
  
  Parametrized is the inverse function to ContainedMaps (73.5-6).
  
    Example  
    gap> Parametrized( [ [ 1, 2, 3, 4, 5 ], [ 1, 3, 2, 4, 5 ],
    >                    [ 1, 2, 3, 4, 6 ] ] );
    [ 1, [ 2, 3 ], [ 2, 3 ], 4, [ 5, 6 ] ]
  
  
  73.5-6 ContainedMaps
  
  ContainedMaps( paramap )  function
  
  For  a  parametrized  map paramap, ContainedMaps returns the set of all maps
  contained in paramap.
  
  ContainedMaps  is the inverse function to Parametrized (73.5-5) in the sense
  that Parametrized( ContainedMaps( paramap ) ) is equal to paramap.
  
    Example  
    gap> ContainedMaps( [ 1, [ 2, 3 ], [ 2, 3 ], 4, [ 5, 6 ] ] );
    [ [ 1, 2, 2, 4, 5 ], [ 1, 2, 2, 4, 6 ], [ 1, 2, 3, 4, 5 ], 
      [ 1, 2, 3, 4, 6 ], [ 1, 3, 2, 4, 5 ], [ 1, 3, 2, 4, 6 ], 
      [ 1, 3, 3, 4, 5 ], [ 1, 3, 3, 4, 6 ] ]
  
  
  73.5-7 UpdateMap
  
  UpdateMap( character, paramap, indirected )  function
  
  Let  character  be  a  map,  paramap  a  parametrized  map, and indirected a
  parametrized map that is contained in CompositionMaps( character, paramap ).
  
  Then  UpdateMap  changes  paramap to the parametrized map containing exactly
  the maps whose composition with character is equal to indirected.
  
  If a contradiction is detected then false is returned immediately, otherwise
  true.
  
    Example  
    gap> subtbl:= CharacterTable("S4(4).2");; tbl:= CharacterTable("He");;
    gap> fus:= InitFusion( subtbl, tbl );;
    gap> fus;
    [ 1, 2, 2, [ 2, 3 ], 4, 4, [ 7, 8 ], [ 7, 8 ], 9, 9, 9, [ 10, 11 ], 
      [ 10, 11 ], 18, 18, 25, 25, [ 26, 27 ], [ 26, 27 ], 2, [ 6, 7 ], 
      [ 6, 7 ], [ 6, 7, 8 ], 10, 10, 17, 17, 18, [ 19, 20 ], [ 19, 20 ] ]
    gap> chi:= Irr( tbl )[2];
    Character( CharacterTable( "He" ), [ 51, 11, 3, 6, 0, 3, 3, -1, 1, 2, 
      0, 3*E(7)+3*E(7)^2+3*E(7)^4, 3*E(7)^3+3*E(7)^5+3*E(7)^6, 2, 
      E(7)+E(7)^2+2*E(7)^3+E(7)^4+2*E(7)^5+2*E(7)^6, 
      2*E(7)+2*E(7)^2+E(7)^3+2*E(7)^4+E(7)^5+E(7)^6, 1, 1, 0, 0, 
      -E(7)-E(7)^2-E(7)^4, -E(7)^3-E(7)^5-E(7)^6, E(7)+E(7)^2+E(7)^4, 
      E(7)^3+E(7)^5+E(7)^6, 1, 0, 0, -1, -1, 0, 0, E(7)+E(7)^2+E(7)^4, 
      E(7)^3+E(7)^5+E(7)^6 ] )
    gap> filt:= Filtered( Irr( subtbl ), x -> x[1] = 50 );
    [ Character( CharacterTable( "S4(4).2" ), 
        [ 50, 10, 10, 2, 5, 5, -2, 2, 0, 0, 0, 1, 1, 0, 0, 0, 0, -1, -1, 
          10, 2, 2, 2, 1, 1, 0, 0, 0, -1, -1 ] ), 
      Character( CharacterTable( "S4(4).2" ), 
        [ 50, 10, 10, 2, 5, 5, -2, 2, 0, 0, 0, 1, 1, 0, 0, 0, 0, -1, -1, 
          -10, -2, -2, -2, -1, -1, 0, 0, 0, 1, 1 ] ) ]
    gap> UpdateMap( chi, fus, filt[1] + TrivialCharacter( subtbl ) );
    true
    gap> fus;
    [ 1, 2, 2, 3, 4, 4, 8, 7, 9, 9, 9, 10, 10, 18, 18, 25, 25, 
      [ 26, 27 ], [ 26, 27 ], 2, [ 6, 7 ], [ 6, 7 ], [ 6, 7 ], 10, 10, 
      17, 17, 18, [ 19, 20 ], [ 19, 20 ] ]
  
  
  73.5-8 MeetMaps
  
  MeetMaps( paramap1, paramap2 )  function
  
  For  two  parametrized maps paramap1 and paramap2, MeetMaps changes paramap1
  such  that  the  image  of  class  i  is the intersection of paramap1[i] and
  paramap2[i].
  
  If  this  implies  that no images remain for a class, the position of such a
  class is returned. If no such inconsistency occurs, MeetMaps returns true.
  
    Example  
    gap> map1:= [ [ 1, 2 ], [ 3, 4 ], 5, 6, [ 7, 8, 9 ] ];;
    gap> map2:= [ [ 1, 3 ], [ 3, 4 ], [ 5, 6 ], 6, [ 8, 9, 10 ] ];;
    gap> MeetMaps( map1, map2 );  map1;
    true
    [ 1, [ 3, 4 ], 5, 6, [ 8, 9 ] ]
  
  
  73.5-9 CommutativeDiagram
  
  CommutativeDiagram( paramap1, paramap2, paramap3, paramap4[, improvements] )  function
  
  Let  paramap1,  paramap2,  paramap3,  paramap4 be parametrized maps covering
  parametrized maps f_1, f_2, f_3, f_4 with the property that CompositionMaps(
  f_2, f_1 ) is equal to CompositionMaps( f_4, f_3 ).
  
  CommutativeDiagram  checks  this consistency, and changes the arguments such
  that  all  possible images are removed that cannot occur in the parametrized
  maps f_i.
  
  The  return  value is fail if an inconsistency was found. Otherwise a record
  with  the  components  imp1, imp2, imp3, imp4 is returned, each bound to the
  list of positions where the corresponding parametrized map was changed,
  
  The  optional  argument  improvements must be a record with components imp1,
  imp2,  imp3,  imp4.  If  such  a  record is specified then only diagrams are
  considered  where  entries  of  the i-th component occur as preimages of the
  i-th parametrized map.
  
  When  an  inconsistency  is detected, CommutativeDiagram immediately returns
  fail.  Otherwise  a  record  is returned that contains four lists imp1, ...,
  imp4:  The i-th component is the list of classes where the i-th argument was
  changed.
  
    Example  
    gap> map1:= [[ 1, 2, 3 ], [ 1, 3 ]];; map2:= [[ 1, 2 ], 1, [ 1, 3 ]];;
    gap> map3:= [ [ 2, 3 ], 3 ];;  map4:= [ , 1, 2, [ 1, 2 ] ];;
    gap> imp:= CommutativeDiagram( map1, map2, map3, map4 );
    rec( imp1 := [ 2 ], imp2 := [ 1 ], imp3 := [  ], imp4 := [  ] )
    gap> map1;  map2;  map3;  map4;
    [ [ 1, 2, 3 ], 1 ]
    [ 2, 1, [ 1, 3 ] ]
    [ [ 2, 3 ], 3 ]
    [ , 1, 2, [ 1, 2 ] ]
    gap> imp2:= CommutativeDiagram( map1, map2, map3, map4, imp );
    rec( imp1 := [  ], imp2 := [  ], imp3 := [  ], imp4 := [  ] )
  
  
  73.5-10 CheckFixedPoints
  
  CheckFixedPoints( inside1, between, inside2 )  function
  
  Let inside1, between, inside2 be parametrized maps, where between is assumed
  to  map  each  fixed  point  of inside1 (that is, inside1[i] = i) to a fixed
  point  of inside2 (that is, between[i] is either an integer that is fixed by
  inside2  or  a  list  that  has  nonempty intersection with the union of its
  images  under  inside2).  CheckFixedPoints  changes  between  and inside2 by
  removing all those entries violate this condition.
  
  When  an  inconsistency  is  detected,  CheckFixedPoints immediately returns
  fail. Otherwise the list of positions is returned where changes occurred.
  
    Example  
    gap> subtbl:= CharacterTable( "L4(3).2_2" );;
    gap> tbl:= CharacterTable( "O7(3)" );;
    gap> fus:= InitFusion( subtbl, tbl );;  fus{ [ 48, 49 ] };
    [ [ 54, 55, 56, 57 ], [ 54, 55, 56, 57 ] ]
    gap> CheckFixedPoints( ComputedPowerMaps( subtbl )[5], fus,
    >        ComputedPowerMaps( tbl )[5] );
    [ 48, 49 ]
    gap> fus{ [ 48, 49 ] };
    [ [ 56, 57 ], [ 56, 57 ] ]
  
  
  73.5-11 TransferDiagram
  
  TransferDiagram( inside1, between, inside2[, improvements] )  function
  
  Let  inside1,  between,  inside2  be parametrized maps covering parametrized
  maps  m_1,  f, m_2 with the property that CompositionMaps( m_2, f ) is equal
  to CompositionMaps( f, m_1 ).
  
  TransferDiagram checks this consistency, and changes the arguments such that
  all  possible  images are removed that cannot occur in the parametrized maps
  m_i and f.
  
  So  TransferDiagram  is  similar to CommutativeDiagram (73.5-9), but between
  occurs twice in each diagram checked.
  
  If  a record improvements with fields impinside1, impbetween, and impinside2
  is  specified,  only those diagrams with elements of impinside1 as preimages
  of  inside1,  elements  of impbetween as preimages of between or elements of
  impinside2 as preimages of inside2 are considered.
  
  When an inconsistency is detected, TransferDiagram immediately returns fail.
  Otherwise  a  record  is  returned  that  contains  three  lists impinside1,
  impbetween, and impinside2 of positions where the arguments were changed.
  
    Example  
    gap> subtbl:= CharacterTable( "2F4(2)" );;  tbl:= CharacterTable( "Ru" );;
    gap> fus:= InitFusion( subtbl, tbl );;
    gap> permchar:= Sum( Irr( tbl ){ [ 1, 5, 6 ] } );;
    gap> CheckPermChar( subtbl, tbl, fus, permchar );; fus;
    [ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, [ 13, 15 ], 16, [ 18, 19 ], 20, 
      [ 25, 26 ], [ 25, 26 ], 5, 5, 6, 8, 14, [ 13, 15 ], [ 18, 19 ], 
      [ 18, 19 ], [ 25, 26 ], [ 25, 26 ], 27, 27 ]
    gap> tr:= TransferDiagram(PowerMap( subtbl, 2), fus, PowerMap(tbl, 2));
    rec( impbetween := [ 12, 23 ], impinside1 := [  ], impinside2 := [  ] 
     )
    gap> tr:= TransferDiagram(PowerMap(subtbl, 3), fus, PowerMap( tbl, 3 ));
    rec( impbetween := [ 14, 24, 25 ], impinside1 := [  ], 
      impinside2 := [  ] )
    gap> tr:= TransferDiagram( PowerMap(subtbl, 3), fus, PowerMap(tbl, 3),
    >             tr );
    rec( impbetween := [  ], impinside1 := [  ], impinside2 := [  ] )
    gap> fus;
    [ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, 15, 16, 18, 20, [ 25, 26 ], 
      [ 25, 26 ], 5, 5, 6, 8, 14, 13, 19, 19, [ 25, 26 ], [ 25, 26 ], 27, 
      27 ]
  
  
  73.5-12 TestConsistencyMaps
  
  TestConsistencyMaps( powermap1, fusionmap, powermap2[, fusimp] )  function
  
  Let  powermap1  and powermap2 be lists of parametrized maps, and fusionmap a
  parametrized  map,  such  that  for  each  i,  the  i-th entry in powermap1,
  fusionmap,  and  the  i-th entry in powermap2 (if bound) are valid arguments
  for   TransferDiagram   (73.5-11).  So  a  typical  situation  for  applying
  TestConsistencyMaps is that fusionmap is an approximation of a class fusion,
  and powermap1, powermap2 are the lists of power maps of the subgroup and the
  group.
  
  TestConsistencyMaps  repeatedly  applies  TransferDiagram (73.5-11) to these
  arguments for all i until no more changes occur.
  
  If  a  list  fusimp  is  specified then only those diagrams with elements of
  fusimp as preimages of fusionmap are considered.
  
  When  an  inconsistency is detected, TestConsistencyMaps immediately returns
  false. Otherwise true is returned.
  
    Example  
    gap> subtbl:= CharacterTable( "2F4(2)" );;  tbl:= CharacterTable( "Ru" );;
    gap> fus:= InitFusion( subtbl, tbl );;
    gap> permchar:= Sum( Irr( tbl ){ [ 1, 5, 6 ] } );;
    gap> CheckPermChar( subtbl, tbl, fus, permchar );; fus;
    [ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, [ 13, 15 ], 16, [ 18, 19 ], 20, 
      [ 25, 26 ], [ 25, 26 ], 5, 5, 6, 8, 14, [ 13, 15 ], [ 18, 19 ], 
      [ 18, 19 ], [ 25, 26 ], [ 25, 26 ], 27, 27 ]
    gap> TestConsistencyMaps( ComputedPowerMaps( subtbl ), fus,
    >        ComputedPowerMaps( tbl ) );
    true
    gap> fus;
    [ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, 15, 16, 18, 20, [ 25, 26 ], 
      [ 25, 26 ], 5, 5, 6, 8, 14, 13, 19, 19, [ 25, 26 ], [ 25, 26 ], 27, 
      27 ]
    gap> Indeterminateness( fus );
    16
  
  
  73.5-13 Indeterminateness
  
  Indeterminateness( paramap )  function
  
  For a parametrized map paramap, Indeterminateness returns the number of maps
  contained  in  paramap,  that is, the product of lengths of lists in paramap
  denoting lists of several images.
  
    Example  
    gap> Indeterminateness([ 1, [ 2, 3 ], [ 4, 5 ], [ 6, 7, 8, 9, 10 ], 11 ]);
    20
  
  
  73.5-14 PrintAmbiguity
  
  PrintAmbiguity( list, paramap )  function
  
  For  each  map in the list list, PrintAmbiguity prints its position in list,
  the  indeterminateness  (see Indeterminateness (73.5-13)) of the composition
  with the parametrized map paramap, and the list of positions where a list of
  images occurs in this composition.
  
    Example  
    gap> paramap:= [ 1, [ 2, 3 ], [ 3, 4 ], [ 2, 3, 4 ], 5 ];;
    gap> list:= [ [ 1, 1, 1, 1, 1 ], [ 1, 1, 2, 2, 3 ], [ 1, 2, 3, 4, 5 ] ];;
    gap> PrintAmbiguity( list, paramap );
    1 1 [  ]
    2 4 [ 2, 4 ]
    3 12 [ 2, 3, 4 ]
  
  
  73.5-15 ContainedSpecialVectors
  
  ContainedSpecialVectors( tbl, chars, paracharacter, func )  function
  IntScalarProducts( tbl, chars, candidate )  function
  NonnegIntScalarProducts( tbl, chars, candidate )  function
  ContainedPossibleVirtualCharacters( tbl, chars, paracharacter )  function
  ContainedPossibleCharacters( tbl, chars, paracharacter )  function
  
  Let  tbl be an ordinary character table, chars a list of class functions (or
  values  lists), paracharacter a parametrized class function of tbl, and func
  a function that expects the three arguments tbl, chars, and a values list of
  a class function, and that returns either true or false.
  
  ContainedSpecialVectors  returns  the  list  of  all  those  elements vec of
  paracharacter that have integral norm, have integral scalar product with the
  principal character of tbl, and that satisfy func( tbl, chars, vec ) = true.
  
  Two  special  cases of func are the check whether the scalar products in tbl
  between  the  vector  vec and all lists in chars are integers or nonnegative
  integers,  respectively.  These functions are accessible as global variables
  IntScalarProducts          and          NonnegIntScalarProducts,         and
  ContainedPossibleVirtualCharacters  and  ContainedPossibleCharacters provide
  access to these special cases of ContainedSpecialVectors.
  
    Example  
    gap> subtbl:= CharacterTable( "HSM12" );;  tbl:= CharacterTable( "HS" );;
    gap> fus:= InitFusion( subtbl, tbl );;
    gap> rest:= CompositionMaps( Irr( tbl )[8], fus );
    [ 231, [ -9, 7 ], [ -9, 7 ], [ -9, 7 ], 6, 15, 15, [ -1, 15 ], 
      [ -1, 15 ], 1, [ 1, 6 ], [ 1, 6 ], [ 1, 6 ], [ 1, 6 ], [ -2, 0 ], 
      [ 1, 2 ], [ 1, 2 ], [ 1, 2 ], 0, 0, 1, 0, 0, 0, 0 ]
    gap> irr:= Irr( subtbl );;
    gap> # no further condition
    gap> cont1:= ContainedSpecialVectors( subtbl, irr, rest,
    >                function( tbl, chars, vec ) return true; end );;
    gap> Length( cont1 );
    24
    gap> # require scalar products to be integral
    gap> cont2:= ContainedSpecialVectors( subtbl, irr, rest,
    >                IntScalarProducts );
    [ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
          0, 1, 0, 0, 0, 0 ], 
      [ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
          0, 1, 0, 0, 0, 0 ], 
      [ 231, 7, -9, -9, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
          0, 1, 0, 0, 0, 0 ], 
      [ 231, 7, -9, 7, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
          0, 1, 0, 0, 0, 0 ] ]
    gap> # additionally require scalar products to be nonnegative
    gap> cont3:= ContainedSpecialVectors( subtbl, irr, rest,
    >                NonnegIntScalarProducts );
    [ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
          0, 1, 0, 0, 0, 0 ], 
      [ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
          0, 1, 0, 0, 0, 0 ] ]
    gap> cont2 = ContainedPossibleVirtualCharacters( subtbl, irr, rest );
    true
    gap> cont3 = ContainedPossibleCharacters( subtbl, irr, rest );
    true
  
  
  73.5-16 CollapsedMat
  
  CollapsedMat( mat, maps )  function
  
  is a record with the components
  
  fusion
        fusion  that  collapses those columns of mat that are equal in mat and
        also for all maps in the list maps,
  
  mat
        the image of mat under that fusion.
  
    Example  
    gap> mat:= [ [ 1, 1, 1, 1 ], [ 2, -1, 0, 0 ], [ 4, 4, 1, 1 ] ];;
    gap> coll:= CollapsedMat( mat, [] );
    rec( fusion := [ 1, 2, 3, 3 ], 
      mat := [ [ 1, 1, 1 ], [ 2, -1, 0 ], [ 4, 4, 1 ] ] )
    gap> List( last.mat, x -> x{ last.fusion } ) = mat;
    true
    gap> coll:= CollapsedMat( mat, [ [ 1, 1, 1, 2 ] ] );
    rec( fusion := [ 1, 2, 3, 4 ], 
      mat := [ [ 1, 1, 1, 1 ], [ 2, -1, 0, 0 ], [ 4, 4, 1, 1 ] ] )
  
  
  73.5-17 ContainedDecomposables
  
  ContainedDecomposables( constituents, moduls, parachar, func )  function
  ContainedCharacters( tbl, constituents, parachar )  function
  
  For these functions, let constituents be a list of rational class functions,
  moduls  a  list of positive integers, parachar a parametrized rational class
  function, func a function that returns either true or false when called with
  (a values list of) a class function, and tbl a character table.
  
  ContainedDecomposables  returns  the  set of all elements χ of parachar that
  satisfy  func(  χ  )  =  true  and  that  lie  in  the  ℤ-lattice spanned by
  constituents,  modulo  moduls.  The  latter  means they lie in the ℤ-lattice
  spanned  by  constituents and the set { moduls[i] ⋅ e_i; 1 ≤ i ≤ n } where n
  is the length of parachar and e_i is the i-th standard basis vector.
  
  One  application of ContainedDecomposables is the following. constituents is
  a  list  of  (values  lists of) rational characters of an ordinary character
  table   tbl,   moduls   is   the   list   of   centralizer   orders  of  tbl
  (see SizesCentralizers  (71.9-2)),  and  func checks whether a vector in the
  lattice  mentioned above has nonnegative integral scalar product in tbl with
  all    entries    of    constituents.   This   situation   is   handled   by
  ContainedCharacters.  Note  that  the  entries  of  the  result list are not
  necessary  linear combinations of constituents, and they are not necessarily
  characters of tbl.
  
    Example  
    gap> subtbl:= CharacterTable( "HSM12" );;  tbl:= CharacterTable( "HS" );;
    gap> rat:= RationalizedMat( Irr( subtbl ) );;
    gap> fus:= InitFusion( subtbl, tbl );;
    gap> rest:= CompositionMaps( Irr( tbl )[8], fus );
    [ 231, [ -9, 7 ], [ -9, 7 ], [ -9, 7 ], 6, 15, 15, [ -1, 15 ], 
      [ -1, 15 ], 1, [ 1, 6 ], [ 1, 6 ], [ 1, 6 ], [ 1, 6 ], [ -2, 0 ], 
      [ 1, 2 ], [ 1, 2 ], [ 1, 2 ], 0, 0, 1, 0, 0, 0, 0 ]
    gap> # compute all vectors in the lattice
    gap> ContainedDecomposables( rat, SizesCentralizers( subtbl ), rest,
    >        ReturnTrue );
    [ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
          0, 1, 0, 0, 0, 0 ], 
      [ 231, 7, -9, -9, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
          0, 1, 0, 0, 0, 0 ], 
      [ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
          0, 1, 0, 0, 0, 0 ], 
      [ 231, 7, -9, 7, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
          0, 1, 0, 0, 0, 0 ] ]
    gap> # compute only those vectors that are characters
    gap> ContainedDecomposables( rat, SizesCentralizers( subtbl ), rest,
    >        x -> NonnegIntScalarProducts( subtbl, Irr( subtbl ), x ) );
    [ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
          0, 1, 0, 0, 0, 0 ], 
      [ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0, 
          0, 1, 0, 0, 0, 0 ] ]
  
  
  
  73.6 Subroutines for the Construction of Power Maps
  
  In the argument lists of the functions Congruences (73.6-2), ConsiderKernels
  (73.6-3),   and   ConsiderSmallerPowerMaps  (73.6-4),  tbl  is  an  ordinary
  character  table, chars a list of (values lists of) characters of tbl, prime
  a  prime  integer, approxmap a parametrized map that is an approximation for
  the  prime-th  power  map  of  tbl  (e.g.,  a  list returned by InitPowerMap
  (73.6-1), and quick a Boolean.
  
  The  quick value true means that only those classes are considered for which
  approxmap lists more than one possible image.
  
  73.6-1 InitPowerMap
  
  InitPowerMap( tbl, prime )  function
  
  For  an ordinary character table tbl and a prime prime, InitPowerMap returns
  a parametrized map that is a first approximation of the prime-th powermap of
  tbl,   using   the   conditions  1. and  2. listed  in  the  description  of
  PossiblePowerMaps (73.1-2).
  
  If  there  are  classes for which no images are possible, according to these
  criteria, then fail is returned.
  
    Example  
    gap> t:= CharacterTable( "U4(3).4" );;
    gap> pow:= InitPowerMap( t, 2 );
    [ 1, 1, 3, 4, 5, [ 2, 16 ], [ 2, 16, 17 ], 8, 3, [ 3, 4 ], 
      [ 11, 12 ], [ 11, 12 ], [ 6, 7, 18, 19, 30, 31, 32, 33 ], 14, 
      [ 9, 20 ], 1, 1, 2, 2, 3, [ 3, 4, 5 ], [ 3, 4, 5 ], 
      [ 6, 7, 18, 19, 30, 31, 32, 33 ], 8, 9, 9, [ 9, 10, 20, 21, 22 ], 
      [ 11, 12 ], [ 11, 12 ], 16, 16, [ 2, 16 ], [ 2, 16 ], 17, 17, 
      [ 6, 18, 30, 31, 32, 33 ], [ 6, 18, 30, 31, 32, 33 ], 
      [ 6, 7, 18, 19, 30, 31, 32, 33 ], [ 6, 7, 18, 19, 30, 31, 32, 33 ], 
      20, 20, [ 9, 20 ], [ 9, 20 ], [ 9, 10, 20, 21, 22 ], 
      [ 9, 10, 20, 21, 22 ], 24, 24, [ 15, 25, 26, 40, 41, 42, 43 ], 
      [ 15, 25, 26, 40, 41, 42, 43 ], [ 28, 29 ], [ 28, 29 ], [ 28, 29 ], 
      [ 28, 29 ] ]
  
  
  73.6-2 Congruences
  
  Congruences( tbl, chars, approxmap, prime, quick )  function
  
  Congruences  replaces the entries of approxmap by improved values, according
  to condition 3. listed in the description of PossiblePowerMaps (73.1-2).
  
  For  each class for which no images are possible according to the tests, the
  new value of approxmap is an empty list. Congruences returns true if no such
  inconsistencies occur, and false otherwise.
  
    Example  
    gap> Congruences( t, Irr( t ), pow, 2, false );  pow;
    true
    [ 1, 1, 3, 4, 5, 2, 2, 8, 3, 4, 11, 12, [ 6, 7 ], 14, 9, 1, 1, 2, 2, 
      3, 4, 5, [ 6, 7 ], 8, 9, 9, 10, 11, 12, 16, 16, 16, 16, 17, 17, 18, 
      18, [ 18, 19 ], [ 18, 19 ], 20, 20, 20, 20, 22, 22, 24, 24, 
      [ 25, 26 ], [ 25, 26 ], 28, 28, 29, 29 ]
  
  
  73.6-3 ConsiderKernels
  
  ConsiderKernels( tbl, chars, approxmap, prime, quick )  function
  
  ConsiderKernels  replaces  the  entries  of  approxmap  by  improved values,
  according  to  condition  4. listed  in the description of PossiblePowerMaps
  (73.1-2).
  
  Congruences  (73.6-2)  returns  true  if  the  orders  of the kernels of all
  characters  in  chars  divide  the  order  of  the  group  of tbl, and false
  otherwise.
  
    Example  
    gap> t:= CharacterTable( "A7.2" );;  init:= InitPowerMap( t, 2 );
    [ 1, 1, 3, 4, [ 2, 9, 10 ], 6, 3, 8, 1, 1, [ 2, 9, 10 ], 3, [ 3, 4 ], 
      6, [ 7, 12 ] ]
    gap> ConsiderKernels( t, Irr( t ), init, 2, false );
    true
    gap> init;
    [ 1, 1, 3, 4, 2, 6, 3, 8, 1, 1, 2, 3, [ 3, 4 ], 6, 7 ]
  
  
  73.6-4 ConsiderSmallerPowerMaps
  
  ConsiderSmallerPowerMaps( tbl, approxmap, prime, quick )  function
  
  ConsiderSmallerPowerMaps  replaces  the  entries  of  approxmap  by improved
  values,   according   to   condition   5. listed   in   the  description  of
  PossiblePowerMaps (73.1-2).
  
  ConsiderSmallerPowerMaps  returns  true  if  each  class admits at least one
  image after the checks, otherwise false is returned. If no element orders of
  tbl  are  stored  (see OrdersClassRepresentatives  (71.9-1))  then  true  is
  returned without any tests.
  
    Example  
    gap> t:= CharacterTable( "3.A6" );;  init:= InitPowerMap( t, 5 );
    [ 1, [ 2, 3 ], [ 2, 3 ], 4, [ 5, 6 ], [ 5, 6 ], [ 7, 8 ], [ 7, 8 ], 
      9, [ 10, 11 ], [ 10, 11 ], 1, [ 2, 3 ], [ 2, 3 ], 1, [ 2, 3 ], 
      [ 2, 3 ] ]
    gap> Indeterminateness( init );
    4096
    gap> ConsiderSmallerPowerMaps( t, init, 5, false );
    true
    gap> Indeterminateness( init );
    256
  
  
  73.6-5 MinusCharacter
  
  MinusCharacter( character, primepowermap, prime )  function
  
  Let  character  be (the list of values of) a class function χ, prime a prime
  integer  p, and primepowermap a parametrized map that is an approximation of
  the  p-th power map for the character table of χ. MinusCharacter returns the
  parametrized  map  of  values  of  χ^{p-}, which is defined by χ^{p-}(g) = (
  χ(g)^p - χ(g^p) ) / p.
  
    Example  
    gap> tbl:= CharacterTable( "S7" );;  pow:= InitPowerMap( tbl, 2 );;
    gap> pow;
    [ 1, 1, 3, 4, [ 2, 9, 10 ], 6, 3, 8, 1, 1, [ 2, 9, 10 ], 3, [ 3, 4 ], 
      6, [ 7, 12 ] ]
    gap> chars:= Irr( tbl ){ [ 2 .. 5 ] };;
    gap> List( chars, x -> MinusCharacter( x, pow, 2 ) );
    [ [ 0, 0, 0, 0, [ 0, 1 ], 0, 0, 0, 0, 0, [ 0, 1 ], 0, 0, 0, [ 0, 1 ] ]
        , 
      [ 15, -1, 3, 0, [ -2, -1, 0 ], 0, -1, 1, 5, -3, [ 0, 1, 2 ], -1, 0, 
          0, [ 0, 1 ] ], 
      [ 15, -1, 3, 0, [ -1, 0, 2 ], 0, -1, 1, 5, -3, [ 1, 2, 4 ], -1, 0, 
          0, 1 ], 
      [ 190, -2, 1, 1, [ 0, 2 ], 0, 1, 1, -10, -10, [ 0, 2 ], -1, -1, 0, 
          [ -1, 0 ] ] ]
  
  
  73.6-6 PowerMapsAllowedBySymmetrizations
  
  PowerMapsAllowedBySymmetrizations( tbl, subchars, chars, approxmap, prime, parameters )  function
  
  Let  tbl  be an ordinary character table, prime a prime integer, approxmap a
  parametrized  map  that is an approximation of the prime-th power map of tbl
  (e.g.,  a  list  returned  by  InitPowerMap (73.6-1), chars and subchars two
  lists  of  (values lists of) characters of tbl, and parameters a record with
  components  maxlen,  minamb, maxamb (three integers), quick (a Boolean), and
  contained  (a  function).  Usual values of contained are ContainedCharacters
  (73.5-17) or ContainedPossibleCharacters (73.5-15).
  
  PowerMapsAllowedBySymmetrizations  replaces  the  entries  of  approxmap  by
  improved  values,  according  to  condition  6. listed in the description of
  PossiblePowerMaps (73.1-2).
  
  More precisely, the strategy used is as follows.
  
  First, for each χ ∈ chars, let minus:= MinusCharacter(χ, approxmap, prime).
  
      If Indeterminateness( minus )= 1 and parameters.quick = false then the
        scalar  products of minus with subchars are checked; if not all scalar
        products  are  nonnegative  integers  then  an empty list is returned,
        otherwise χ is deleted from the list of characters to inspect.
  
      Otherwise    if   Indeterminateness(   minus   )   is   smaller   than
        parameters.minamb then χ is deleted from the list of characters.
  
      If  parameters.minamb ≤ Indeterminateness( minus ) ≤ parameters.maxamb
        then   construct   the   list  of  contained  class  functions  poss:=
        parameters.contained(tbl,  subchars,  minus) and Parametrized( poss ),
        and  improve  the  approximation  of  the  power  map  using UpdateMap
        (73.5-7).
  
  If this yields no further immediate improvements then we branch. If there is
  a  character  from  chars left with less or equal parameters.maxlen possible
  symmetrizations,   compute   the  union  of  power  maps  allowed  by  these
  possibilities.  Otherwise  we  choose  a  class  C  such  that  the possible
  symmetrizations of a character in chars differ at C, and compute recursively
  the  union  of all allowed power maps with image at C fixed in the set given
  by the current approximation of the power map.
  
    Example  
    gap> tbl:= CharacterTable( "U4(3).4" );;
    gap> pow:= InitPowerMap( tbl, 2 );;
    gap> Congruences( tbl, Irr( tbl ), pow, 2 );;  pow;
    [ 1, 1, 3, 4, 5, 2, 2, 8, 3, 4, 11, 12, [ 6, 7 ], 14, 9, 1, 1, 2, 2, 
      3, 4, 5, [ 6, 7 ], 8, 9, 9, 10, 11, 12, 16, 16, 16, 16, 17, 17, 18, 
      18, [ 18, 19 ], [ 18, 19 ], 20, 20, 20, 20, 22, 22, 24, 24, 
      [ 25, 26 ], [ 25, 26 ], 28, 28, 29, 29 ]
    gap> PowerMapsAllowedBySymmetrizations( tbl, Irr( tbl ), Irr( tbl ),
    >       pow, 2, rec( maxlen:= 10, contained:= ContainedPossibleCharacters,
    >       minamb:= 2, maxamb:= infinity, quick:= false ) );
    [ [ 1, 1, 3, 4, 5, 2, 2, 8, 3, 4, 11, 12, 6, 14, 9, 1, 1, 2, 2, 3, 4, 
          5, 6, 8, 9, 9, 10, 11, 12, 16, 16, 16, 16, 17, 17, 18, 18, 18, 
          18, 20, 20, 20, 20, 22, 22, 24, 24, 25, 26, 28, 28, 29, 29 ] ]
  
  
  
  73.7 Subroutines for the Construction of Class Fusions
  
  73.7-1 InitFusion
  
  InitFusion( subtbl, tbl )  function
  
  For  two  ordinary  character  tables  subtbl  and tbl, InitFusion returns a
  parametrized  map  that  is  a  first approximation of the class fusion from
  subtbl   to   tbl,   using   condition 1. listed   in   the  description  of
  PossibleClassFusions (73.3-6).
  
  If  there  are  classes  for which no images are possible, according to this
  criterion, then fail is returned.
  
    Example  
    gap> subtbl:= CharacterTable( "2F4(2)" );;  tbl:= CharacterTable( "Ru" );;
    gap> fus:= InitFusion( subtbl, tbl );
    [ 1, 2, 2, 4, [ 5, 6 ], [ 5, 6, 7, 8 ], [ 5, 6, 7, 8 ], [ 9, 10 ], 
      11, 14, 14, [ 13, 14, 15 ], [ 16, 17 ], [ 18, 19 ], 20, [ 25, 26 ], 
      [ 25, 26 ], [ 5, 6 ], [ 5, 6 ], [ 5, 6 ], [ 5, 6, 7, 8 ], 
      [ 13, 14, 15 ], [ 13, 14, 15 ], [ 18, 19 ], [ 18, 19 ], [ 25, 26 ], 
      [ 25, 26 ], [ 27, 28, 29 ], [ 27, 28, 29 ] ]
  
  
  73.7-2 CheckPermChar
  
  CheckPermChar( subtbl, tbl, approxmap, permchar )  function
  
  CheckPermChar  replaces  the  entries  of  the parametrized map approxmap by
  improved  values,  according  to  condition 3. listed  in the description of
  PossibleClassFusions (73.3-6).
  
  CheckPermChar   returns   true  if  no  inconsistency  occurred,  and  false
  otherwise.
  
    Example  
    gap> permchar:= Sum( Irr( tbl ){ [ 1, 5, 6 ] } );;
    gap> CheckPermChar( subtbl, tbl, fus, permchar ); fus;
    true
    [ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, [ 13, 15 ], 16, [ 18, 19 ], 20, 
      [ 25, 26 ], [ 25, 26 ], 5, 5, 6, 8, 14, [ 13, 15 ], [ 18, 19 ], 
      [ 18, 19 ], [ 25, 26 ], [ 25, 26 ], 27, 27 ]
  
  
  73.7-3 ConsiderTableAutomorphisms
  
  ConsiderTableAutomorphisms( approxmap, grp )  function
  
  ConsiderTableAutomorphisms  replaces  the  entries  of  the parametrized map
  approxmap  by  improved  values,  according  to  condition 4. listed  in the
  description of PossibleClassFusions (73.3-6).
  
  Afterwards   exactly   one  representative  of  fusion  maps  (contained  in
  approxmap)  in  each  orbit under the action of the permutation group grp is
  contained in the modified parametrized map.
  
  ConsiderTableAutomorphisms returns the list of positions where approxmap was
  changed.
  
    Example  
    gap> ConsiderTableAutomorphisms( fus, AutomorphismsOfTable( tbl ) );
    [ 16 ]
    gap> fus;
    [ 1, 2, 2, 4, 5, 7, 8, 9, 11, 14, 14, [ 13, 15 ], 16, [ 18, 19 ], 20, 
      25, [ 25, 26 ], 5, 5, 6, 8, 14, [ 13, 15 ], [ 18, 19 ], [ 18, 19 ], 
      [ 25, 26 ], [ 25, 26 ], 27, 27 ]
  
  
  73.7-4 FusionsAllowedByRestrictions
  
  FusionsAllowedByRestrictions( subtbl, tbl, subchars, chars, approxmap, parameters )  function
  
  Let  subtbl  and  tbl  be  ordinary character tables, subchars and chars two
  lists  of  (values  lists  of)  characters  of subtbl and tbl, respectively,
  approxmap a parametrized map that is an approximation of the class fusion of
  subtbl in tbl, and parameters a record with the mandatory components maxlen,
  minamb,  maxamb  (three  integers),  quick  (a  Boolean),  and  contained (a
  function,    usual    values    are    ContainedCharacters    (73.5-17)   or
  ContainedPossibleCharacters   (73.5-15));   optional   components   of   the
  parameters  record are testdec (the function that tests the decomposability,
  the default is NonnegIntScalarProducts (73.5-15)), powermaps (the power paps
  of  subtbl  that  shall be used for compatibility checks, the default is the
  ComputedPowerMaps  (73.1-1) value), subpowermaps (the power paps of tbl that
  shall be used for compatibility checks, the default is the ComputedPowerMaps
  (73.1-1) value).
  
  FusionsAllowedByRestrictions  replaces  the entries of approxmap by improved
  values,   according   to   condition   5. listed   in   the  description  of
  PossibleClassFusions (73.3-6).
  
  More precisely, the strategy used is as follows.
  
  First, for each χ ∈ chars, let restricted:= CompositionMaps( χ, approxmap ).
  
      If  Indeterminateness(  restricted  )=  1 and parameters.quick = false
        then  the  scalar products of restricted with subchars are checked; if
        not all scalar products are nonnegative integers then an empty list is
        returned,  otherwise  χ  is  deleted  from  the  list of characters to
        inspect.
  
      Otherwise    if   Indeterminateness(   minus   )   is   smaller   than
        parameters.minamb then χ is deleted from the list of characters.
  
      If    parameters.minamb    ≤   Indeterminateness(   restricted   )   ≤
        parameters.maxamb  then construct poss:= parameters.contained( subtbl,
        subchars,  restricted  )  and  Parametrized(  poss  ), and improve the
        approximation of the fusion map using UpdateMap (73.5-7).
  
  If this yields no further immediate improvements then we branch. If there is
  a  character  from  chars left with less or equal parameters.maxlen possible
  restrictions,   compute   the   union   of  fusion  maps  allowed  by  these
  possibilities.  Otherwise  we  choose  a  class  C  such  that  the possible
  restrictions  of  a  character in chars differ at C, and compute recursively
  the  union of all allowed fusion maps with image at C fixed in the set given
  by the current approximation of the fusion map.
  
    Example  
    gap> subtbl:= CharacterTable( "U3(3)" );;  tbl:= CharacterTable( "J4" );;
    gap> fus:= InitFusion( subtbl, tbl );;
    gap> TestConsistencyMaps( ComputedPowerMaps( subtbl ), fus,
    >        ComputedPowerMaps( tbl ) );
    true
    gap> fus;
    [ 1, 2, 4, 4, [ 5, 6 ], [ 5, 6 ], [ 5, 6 ], 10, [ 12, 13 ], 
      [ 12, 13 ], [ 14, 15, 16 ], [ 14, 15, 16 ], [ 21, 22 ], [ 21, 22 ] ]
    gap> ConsiderTableAutomorphisms( fus, AutomorphismsOfTable( tbl ) );
    [ 9 ]
    gap> fus;
    [ 1, 2, 4, 4, [ 5, 6 ], [ 5, 6 ], [ 5, 6 ], 10, 12, [ 12, 13 ], 
      [ 14, 15, 16 ], [ 14, 15, 16 ], [ 21, 22 ], [ 21, 22 ] ]
    gap> FusionsAllowedByRestrictions( subtbl, tbl, Irr( subtbl ),
    >        Irr( tbl ), fus, rec( maxlen:= 10,
    >        contained:= ContainedPossibleCharacters, minamb:= 2,
    >        maxamb:= infinity, quick:= false ) );
    [ [ 1, 2, 4, 4, 5, 5, 6, 10, 12, 13, 14, 14, 21, 21 ], 
      [ 1, 2, 4, 4, 6, 6, 6, 10, 12, 13, 15, 15, 22, 22 ], 
      [ 1, 2, 4, 4, 6, 6, 6, 10, 12, 13, 16, 16, 22, 22 ] ]