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

  
  2 Tutorial for the GAP Character Table Library
  
  This  chapter  gives  an overview of the basic functionality provided by the
  GAP  Character  Table Library. The main concepts and interface functions are
  presented  in  the  sections[14 X2.1  and  2.2,  Section[14 X2.3  shows  a few small
  examples.
  
  In order to force that the examples consist only of ASCII characters, we set
  the  user  preference  DisplayFunction of the AtlasRep to the value "Print".
  This is necessary because the LaTeX and HTML versions of GAPDoc documents do
  not support non-ASCII characters.
  
    Example  
    gap> origpref:= UserPreference( "AtlasRep", "DisplayFunction" );;
    gap> SetUserPreference( "AtlasRep", "DisplayFunction", "Print" );
  
  
  
  2.1 Concepts used in the GAP Character Table Library
  
  The main idea behind working with the GAP Character Table Library is to deal
  with  character  tables of groups but without having access to these groups.
  This  situation  occurs  for  example  if  one extracts information from the
  printed Atlas of Finite Groups ([CCN+85]).
  
  This  restriction  means  first  of  all  that  we  need a way to access the
  character  tables,  see  Section 2.2 for that. Once we have such a character
  table, we can compute all those data about the underlying group G, say, that
  are  determined  by  the character table. Chapter 'Reference: Attributes and
  Properties  for  Groups  and  Character  Tables'  lists  such attributes and
  properties.  For  example,  it can be computed from the character table of G
  whether G is solvable or not.
  
  Questions  that  cannot  be answered using only the character table of G can
  perhaps  be treated using additional information. For example, the structure
  of  subgroups of G is in general not determined by the character table of G,
  but  the  character table may yield partial information. Two examples can be
  found in the sections 2.3-4 and 2.3-6.
  
  In the character table context, the role of homomorphisms between two groups
  is  taken  by  class  fusions. Monomorphisms correspond to subgroup fusions,
  epimorphisms  correspond  to factor fusions. Given two character tables of a
  group  G  and  a subgroup H of G, one can in general compute only candidates
  for  the  class  fusion  of H into G, for example using PossibleClassFusions
  (Reference:   PossibleClassFusions).   Note   that  G  may  contain  several
  nonconjugate  subgroups  isomorphic  with  H, which may have different class
  fusions.
  
  One  can  often  reduce  a  question about a group G to a question about its
  maximal subgroups. In the character table context, it is often sufficient to
  know  the  character  table  of  G,  the  character  tables  of  its maximal
  subgroups,  and  their class fusions into G. We are in this situation if the
  attribute Maxes (3.7-1) is set in the character table of G.
  
  Summary:  The  character  theoretic  approach  that  is supported by the GAP
  Character  Table  Library, that is, an approach without explicitly using the
  underlying  groups,  has  the  advantages that it can be used to answer many
  questions,  and  that  these  computations  are  usually  cheap, compared to
  computations with groups. Disadvantages are that this approach is not always
  successful, and that answers are often nonconstructive in the sense that one
  can show the existence of something without getting one's hands on it.
  
  
  2.2 Accessing a Character Table from the Library
  
  As  stated  in Section 2.1, we must define how character tables from the GAP
  Character Table Library can be accessed.
  
  
  2.2-1 Accessing a Character Table via a name
  
  The most common way to access a character table from the GAP Character Table
  Library  is to call CharacterTable (3.1-2) with argument a string that is an
  admissible  name  for  the  character  table.  Typical  admissible names are
  similar  to the group names used in the Atlas of Finite Groups [CCN+85]. One
  of  these  names  is  the  Identifier  (Reference:  Identifier for character
  tables)  value  of  the  character  table,  this name is used by GAP when it
  prints library character tables.
  
  For  example, an admissible name for the character table of an almost simple
  group  is  the  Atlas name, such as A5, M11, or L2(11).2. Other names may be
  admissible,  for  example  S6  is  admissible for the symmetric group on six
  points, which is called A_6.2_1 in the Atlas.
  
    Example  
    gap> CharacterTable( "J1" );
    CharacterTable( "J1" )
    gap> CharacterTable( "L2(11)" );
    CharacterTable( "L2(11)" )
    gap> CharacterTable( "S5" );
    CharacterTable( "A5.2" )
  
  
  
  2.2-2 Accessing a Character Table via properties
  
  If  one  does  not know an admissible name of the character table of a group
  one is interested in, or if one does not know whether ths character table is
  available  at  all,  one can use AllCharacterTableNames (3.1-4) to compute a
  list of identifiers of all available character tables with given properties.
  Analogously,  OneCharacterTableName  (3.1-5) can be used to compute one such
  identifier.
  
    Example  
    gap> AllCharacterTableNames( Size, 168 );
    [ "(2^2xD14):3", "2^3.7.3", "L3(2)", "L3(4)M7", "L3(4)M8" ]
    gap> OneCharacterTableName( NrConjugacyClasses, n -> n <= 4 );
    "S3"
  
  
  For  certain  filters, such as Size (Reference: Size) and NrConjugacyClasses
  (Reference:  NrConjugacyClasses),  the  computations  are  fast  because the
  values  for  all  library tables are precomputed. See AllCharacterTableNames
  (3.1-4) for an overview of these filters.
  
  The  function  BrowseCTblLibInfo (3.5-2) provides an interactive overview of
  available  character tables, which allows one for example to search also for
  substrings  in  identifiers  of character tables. This function is available
  only if the Browse package has been loaded.
  
  
  2.2-3 Accessing a Character Table via a Table of Marks
  
  Let  G  be  a group whose table of marks is available via the TomLib package
  (see  [NMP18]  for how to access tables of marks from this library) then the
  GAP  Character  Table Library contains the character table of G, and one can
  access   this  table  by  using  the  table  of  marks  as  an  argument  of
  CharacterTable (3.2-2).
  
    Example  
    gap> tom:= TableOfMarks( "M11" );
    TableOfMarks( "M11" )
    gap> t:= CharacterTable( tom );
    CharacterTable( "M11" )
  
  
  
  2.2-4 Accessing a Character Table relative to another Character Table
  
  If  one  has  already a character table from the GAP Character Table Library
  that  belongs to the group G, say, then names of related tables can be found
  as follows.
  
  The  value  of  the  attribute  Maxes  (3.7-1),  if  known,  is  the list of
  identifiers  of  the character tables of all classes of maximal subgroups of
  G.
  
    Example  
    gap> t:= CharacterTable( "M11" );
    CharacterTable( "M11" )
    gap> HasMaxes( t );
    true
    gap> Maxes( t );
    [ "A6.2_3", "L2(11)", "3^2:Q8.2", "A5.2", "2.S4" ]
  
  
  If  the  Maxes (3.7-1) value of the character table with identifier id, say,
  is known then the character table of the groups in the i-th class of maximal
  subgroups can be accessed via the relative name idMi.
  
    Example  
    gap> CharacterTable( "M11M2" );
    CharacterTable( "L2(11)" )
  
  
  The    value    of    the    attribute    NamesOfFusionSources   (Reference:
  NamesOfFusionSources)  is  the list of identifiers of those character tables
  which  store  class  fusions  to  G.  So  these  character  tables belong to
  subgroups of G and groups that have G as a factor group.
  
    Example  
    gap> NamesOfFusionSources( t );
    [ "A5.2", "A6.2_3", "P48/G1/L1/V1/ext2", "P48/G1/L1/V2/ext2", 
      "L2(11)", "2.S4", "3^5:M11", "3^6.M11", "s4", "3^2:Q8.2", "M11N2", 
      "5:4", "11:5" ]
  
  
  The    value    of    the    attribute    ComputedClassFusions   (Reference:
  ComputedClassFusions)  is  the list of records whose name components are the
  identifiers  of those character tables to which class fusions are stored. So
  these character tables belong to overgroups and factor groups of G.
  
    Example  
    gap> List( ComputedClassFusions( t ), r -> r.name );
    [ "A11", "M12", "M23", "HS", "McL", "ON", "3^5:M11", "B" ]
  
  
  
  2.2-5 Different character tables for the same group
  
  The  GAP  Character  Table  Library  may contain several different character
  tables  of  a given group, in the sense that the rows and columns are sorted
  differently.
  
  For  example, the Atlas table of the alternating group A_5 is available, and
  since  A_5  is  isomorphic with the groups PSL(2, 4) and PSL(2, 5), two more
  character  tables  of  A_5  can  be  constructed in a natural way. The three
  tables are of course permutation isomorphic. The first two are sorted in the
  same way, but the rows and columns of the third one are sorted differently.
  
    Example  
    gap> t1:= CharacterTable( "A5" );;
    gap> t2:= CharacterTable( "PSL", 2, 4 );;
    gap> t3:= CharacterTable( "PSL", 2, 5 );;
    gap> TransformingPermutationsCharacterTables( t1, t2 );
    rec( columns := (), group := Group([ (4,5) ]), rows := () )
    gap> TransformingPermutationsCharacterTables( t1, t3 );
    rec( columns := (2,4)(3,5), group := Group([ (2,3) ]), 
      rows := (2,5,3,4) )
  
  
  Another  situation  where  several  character  tables for the same group are
  available  is  that  a  group contains several classes of isomorphic maximal
  subgroups such that the class fusions are different.
  
  For  example,  the  Mathieu  group  M_12  contains  two  classes  of maximal
  subgroups of index 12, which are isomorphic with M_11.
  
    Example  
    gap> t:= CharacterTable( "M12" );
    CharacterTable( "M12" )
    gap> mx:= Maxes( t );
    [ "M11", "M12M2", "A6.2^2", "M12M4", "L2(11)", "3^2.2.S4", "M12M7", 
      "2xS5", "M8.S4", "4^2:D12", "A4xS3" ]
    gap> s1:= CharacterTable( mx[1] );
    CharacterTable( "M11" )
    gap> s2:= CharacterTable( mx[2] );
    CharacterTable( "M12M2" )
  
  
  The  class fusions into M_12 are stored on the library tables of the maximal
  subgroups.  The  groups  in  the  first class of M_11 type subgroups contain
  elements in the classes 4B, 6B, and 8B of M_12, and the groups in the second
  class contain elements in the classes 4A, 6A, and 8A. Note that according to
  the Atlas (see [CCN+85, p. 33]), the permutation characters of the action of
  M_12  on  the  cosets of M_11 type subgroups from the two classes of maximal
  subgroups are 1a + 11a and 1a + 11b, respectively.
  
    Example  
    gap> GetFusionMap( s1, t );
    [ 1, 3, 4, 7, 8, 10, 12, 12, 15, 14 ]
    gap> GetFusionMap( s2, t );
    [ 1, 3, 4, 6, 8, 10, 11, 11, 14, 15 ]
    gap> Display( t );
    M12
    
          2   6  4  6  1  2  5  5  1  2  1  3  3   1   .   .
          3   3  1  1  3  2  .  .  .  1  1  .  .   .   .   .
          5   1  1  .  .  .  .  .  1  .  .  .  .   1   .   .
         11   1  .  .  .  .  .  .  .  .  .  .  .   .   1   1
    
             1a 2a 2b 3a 3b 4a 4b 5a 6a 6b 8a 8b 10a 11a 11b
         2P  1a 1a 1a 3a 3b 2b 2b 5a 3b 3a 4a 4b  5a 11b 11a
         3P  1a 2a 2b 1a 1a 4a 4b 5a 2a 2b 8a 8b 10a 11a 11b
         5P  1a 2a 2b 3a 3b 4a 4b 1a 6a 6b 8a 8b  2a 11a 11b
        11P  1a 2a 2b 3a 3b 4a 4b 5a 6a 6b 8a 8b 10a  1a  1a
    
    X.1       1  1  1  1  1  1  1  1  1  1  1  1   1   1   1
    X.2      11 -1  3  2 -1 -1  3  1 -1  . -1  1  -1   .   .
    X.3      11 -1  3  2 -1  3 -1  1 -1  .  1 -1  -1   .   .
    X.4      16  4  . -2  1  .  .  1  1  .  .  .  -1   A  /A
    X.5      16  4  . -2  1  .  .  1  1  .  .  .  -1  /A   A
    X.6      45  5 -3  .  3  1  1  . -1  . -1 -1   .   1   1
    X.7      54  6  6  .  .  2  2 -1  .  .  .  .   1  -1  -1
    X.8      55 -5  7  1  1 -1 -1  .  1  1 -1 -1   .   .   .
    X.9      55 -5 -1  1  1  3 -1  .  1 -1 -1  1   .   .   .
    X.10     55 -5 -1  1  1 -1  3  .  1 -1  1 -1   .   .   .
    X.11     66  6  2  3  . -2 -2  1  . -1  .  .   1   .   .
    X.12     99 -1  3  .  3 -1 -1 -1 -1  .  1  1  -1   .   .
    X.13    120  . -8  3  .  .  .  .  .  1  .  .   .  -1  -1
    X.14    144  4  .  . -3  .  . -1  1  .  .  .  -1   1   1
    X.15    176 -4  . -4 -1  .  .  1 -1  .  .  .   1   .   .
    
    A = E(11)+E(11)^3+E(11)^4+E(11)^5+E(11)^9
      = (-1+Sqrt(-11))/2 = b11
  
  
  Permutation  equivalent  library  tables  are  related to each other. In the
  above  example,  the  table s2 is a duplicate of s1, and there are functions
  for making the relations explicit.
  
    Example  
    gap> IsDuplicateTable( s2 );
    true
    gap> IdentifierOfMainTable( s2 );
    "M11"
    gap> IdentifiersOfDuplicateTables( s1 );
    [ "HSM9", "M12M2", "ONM11" ]
  
  
  See Section[14 X3.6 for details about duplicate character tables.
  
  
  2.3 Examples of Using the GAP Character Table Library
  
  The   sections   2.3-1,   2.3-2,   and   2.3-3   show   how   the   function
  AllCharacterTableNames  (3.1-4)  can  be used to search for character tables
  with  certain  properties.  The GAP Character Table Library serves as a tool
  for finding and checking conjectures in these examples.
  
  In Section 2.3-6, a question about a subgroup of the sporadic simple Fischer
  group  G  =  Fi_23  is  answered  using  only  character tables from the GAP
  Character Table Library.
  
  More examples can be found in [BGL+10], [Brea], [Bred], [Bree], [Bref].
  
  
  2.3-1 Example: Ambivalent Simple Groups
  
  A  group  G  is called ambivalent if each element in G is G-conjugate to its
  inverse.   Equivalently,   G   is  ambivalent  if  all  its  characters  are
  real-valued. We are interested in nonabelian simple ambivalent groups. Since
  ambivalence  is  of  course  invariant under permutation equivalence, we may
  omit duplicate character tables.
  
    Example  
    gap> isambivalent:= tbl -> PowerMap( tbl, -1 )
    >                            = [ 1 .. NrConjugacyClasses( tbl ) ];;
    gap> AllCharacterTableNames( IsSimple, true, IsDuplicateTable, false,
    >        IsAbelian, false, isambivalent, true );
    [ "3D4(2)", "3D4(3)", "3D4(4)", "A10", "A14", "A5", "A6", "J1", "J2", 
      "L2(101)", "L2(109)", "L2(113)", "L2(121)", "L2(125)", "L2(13)", 
      "L2(16)", "L2(17)", "L2(25)", "L2(29)", "L2(32)", "L2(37)", 
      "L2(41)", "L2(49)", "L2(53)", "L2(61)", "L2(64)", "L2(73)", 
      "L2(8)", "L2(81)", "L2(89)", "L2(97)", "O12+(2)", "O12-(2)", 
      "O12-(3)", "O7(5)", "O8+(2)", "O8+(3)", "O8+(7)", "O8-(2)", 
      "O8-(3)", "O9(3)", "S10(2)", "S12(2)", "S4(4)", "S4(5)", "S4(8)", 
      "S4(9)", "S6(2)", "S6(4)", "S6(5)", "S8(2)" ]
  
  
  
  2.3-2 Example: Simple p-pure Groups
  
  A  group  G  is  called p-pure for a prime integer p that divides |G| if the
  centralizer   orders   of   nonidentity   p-elements   in  G  are  p-powers.
  Equivalently,  G  is  p-pure if p divides |G| and each element in G of order
  divisible  by p is a p-element. (This property was studied by L. Héthelyi in
  2002.)
  
  We are interested in small nonabelian simple p-pure groups.
  
    Example  
    gap> isppure:= function( p )
    >      return tbl -> Size( tbl ) mod p = 0 and
    >        ForAll( OrdersClassRepresentatives( tbl ),
    >                n -> n mod p <> 0 or IsPrimePowerInt( n ) );
    >    end;;
    gap> for i in [ 2, 3, 5, 7, 11, 13 ] do
    >      Print( i, "\n",
    >        AllCharacterTableNames( IsSimple, true, IsAbelian, false,
    >            IsDuplicateTable, false, isppure( i ), true ),
    >        "\n" );
    >    od;
    2
    [ "A5", "A6", "L2(16)", "L2(17)", "L2(31)", "L2(32)", "L2(64)", 
      "L2(8)", "L3(2)", "L3(4)", "Sz(32)", "Sz(8)" ]
    3
    [ "A5", "A6", "L2(17)", "L2(19)", "L2(27)", "L2(53)", "L2(8)", 
      "L2(81)", "L3(2)", "L3(4)" ]
    5
    [ "A5", "A6", "A7", "L2(11)", "L2(125)", "L2(25)", "L2(49)", "L3(4)", 
      "M11", "M22", "S4(7)", "Sz(32)", "Sz(8)", "U4(2)", "U4(3)" ]
    7
    [ "A7", "A8", "A9", "G2(3)", "HS", "J1", "J2", "L2(13)", "L2(49)", 
      "L2(8)", "L2(97)", "L3(2)", "L3(4)", "M22", "O8+(2)", "S6(2)", 
      "Sz(8)", "U3(3)", "U3(5)", "U4(3)", "U6(2)" ]
    11
    [ "A11", "A12", "A13", "Co2", "HS", "J1", "L2(11)", "L2(121)", 
      "L2(23)", "L5(3)", "M11", "M12", "M22", "M23", "M24", "McL", 
      "O10+(3)", "O12+(3)", "ON", "Suz", "U5(2)", "U6(2)" ]
    13
    [ "2E6(2)", "2F4(2)'", "3D4(2)", "A13", "A14", "A15", "F4(2)", 
      "Fi22", "G2(3)", "G2(4)", "L2(13)", "L2(25)", "L2(27)", "L3(3)", 
      "L4(3)", "O7(3)", "O8+(3)", "S4(5)", "S6(3)", "Suz", "Sz(8)", 
      "U3(4)" ]
  
  
  Looking  at these examples, we may observe that the alternating group A_n of
  degree  n  is 2-pure iff n ∈ { 4, 5, 6 }, 3-pure iff n ∈ { 3, 4, 5, 6 }, and
  p-pure, for p ≥ 5, iff n ∈ { p, p+1, p+2 }.
  
  Also,  the  Suzuki  groups  Sz(q)  are  2-pure  since  the  centralizers  of
  nonidentity 2-elements are contained in Sylow 2-subgroups.
  
  From  the  inspection of the generic character table(s) of PSL(2, q), we see
  that  PSL(2,  p^d)  is  p-pure  Additionally, exactly the following cases of
  l-purity occur, for a prime l.
  
      q is even and q-1 or q+1 is a power of l.
  
      For q ≡ 1 mod 4, (q+1)/2 is a power of l or q-1 is a power of l = 2.
  
      For q ≡ 3 mod 4, (q-1)/2 is a power of l or q+1 is a power of l = 2.
  
  
  2.3-3 Example: Simple Groups with only one p-Block
  
  Are there nonabelian simple groups with only one p-block, for some prime p?
  
    Example  
    gap> fun:= function( tbl )
    >      local result, p, bl;
    > 
    >      result:= false;
    >      for p in PrimeDivisors( Size( tbl ) ) do
    >        bl:= PrimeBlocks( tbl, p );
    >        if Length( bl.defect ) = 1 then
    >          result:= true;
    >          Print( "only one block: ", Identifier( tbl ), ", p = ", p, "\n" );
    >        fi;
    >      od;
    > 
    >      return result;
    > end;;
    gap> AllCharacterTableNames( IsSimple, true, IsAbelian, false,
    >                            IsDuplicateTable, false, fun, true );
    only one block: M22, p = 2
    only one block: M24, p = 2
    [ "M22", "M24" ]
  
  
  We see that the sporadic simple groups M_22 and M_24 have only one 2-block.
  
  
  2.3-4 Example:The Sylow 3 subgroup of 3.O'N
  
  We  want  to  determine the structure of the Sylow 3-subgroups of the triple
  cover G = 3.O'N of the sporadic simple O'Nan group O'N. The Sylow 3-subgroup
  of  O'N  is  an  elementary  abelian  group  of order 3^4, since the Sylow 3
  normalizer in O'N has the structure 3^4:2^1+4D_10 (see [CCN+85, p. 132]).
  
    Example  
    gap> CharacterTable( "ONN3" );
    CharacterTable( "3^4:2^(1+4)D10" )
  
  
  Let  P  be  a  Sylow  3-subgroup  of  G.  Then  P  is not abelian, since the
  centralizer order of any preimage of an element of order three in the simple
  factor  group  of  G is not divisible by 3^5. Moreover, the exponent of P is
  three.
  
    Example  
    gap> 3t:= CharacterTable( "3.ON" );;
    gap> orders:= OrdersClassRepresentatives( 3t );;
    gap> ord3:= PositionsProperty( orders, x -> x = 3 );
    [ 2, 3, 7 ]
    gap> sizes:= SizesCentralizers( 3t ){ ord3 };
    [ 1382446517760, 1382446517760, 3240 ]
    gap> Size( 3t );
    1382446517760
    gap> Collected( Factors( sizes[3] ) );
    [ [ 2, 3 ], [ 3, 4 ], [ 5, 1 ] ]
    gap> 9 in orders;
    false
  
  
  So both the centre and the Frattini subgroup of P are equal to the centre of
  G, hence P is an extraspecial group 3^1+4_+.
  
  
  2.3-5 Example: Primitive Permutation Characters of 2.A_6
  
  It is often interesting to compute the primitive permutation characters of a
  group  G,  that  is,  the  characters of the permutation actions of G on the
  cosets  of  its  maximal  subgroups.  These  characters  can be computed for
  example  when the character tables of G, the character tables of its maximal
  subgroups,  and the class fusions from these character tables into the table
  of G are known.
  
    Example  
    gap> tbl:= CharacterTable( "2.A6" );;
    gap> HasMaxes( tbl );
    true
    gap> maxes:= Maxes( tbl );
    [ "2.A5", "2.A6M2", "3^2:8", "2.Symm(4)", "2.A6M5" ]
    gap> mx:= List( maxes, CharacterTable );;
    gap> prim1:= List( mx, s -> TrivialCharacter( s )^tbl );;
    gap> Display( tbl,
    >      rec( chars:= prim1, centralizers:= false, powermap:= false ) );
    2.A6
    
           1a 2a 4a 3a 6a 3b 6b 8a 8b 5a 10a 5b 10b
    
    Y.1     6  6  2  3  3  .  .  .  .  1   1  1   1
    Y.2     6  6  2  .  .  3  3  .  .  1   1  1   1
    Y.3    10 10  2  1  1  1  1  2  2  .   .  .   .
    Y.4    15 15  3  3  3  .  .  1  1  .   .  .   .
    Y.5    15 15  3  .  .  3  3  1  1  .   .  .   .
  
  
  These permutation characters are the ones listed in [CCN+85, p. 4].
  
    Example  
    gap> PermCharInfo( tbl, prim1 ).ATLAS;
    [ "1a+5a", "1a+5b", "1a+9a", "1a+5a+9a", "1a+5b+9a" ]
  
  
  Alternatively, one can compute the primitive permutation characters from the
  table of marks if this table and the fusion into it are known.
  
    Example  
    gap> tom:= TableOfMarks( tbl );
    TableOfMarks( "2.A6" )
    gap> allperm:= PermCharsTom( tbl, tom );;
    gap> prim2:= allperm{ MaximalSubgroupsTom( tom )[1] };;
    gap> Display( tbl,
    >      rec( chars:= prim2, centralizers:= false, powermap:= false ) );
    2.A6
    
           1a 2a 4a 3a 6a 3b 6b 8a 8b 5a 10a 5b 10b
    
    Y.1     6  6  2  3  3  .  .  .  .  1   1  1   1
    Y.2     6  6  2  .  .  3  3  .  .  1   1  1   1
    Y.3    10 10  2  1  1  1  1  2  2  .   .  .   .
    Y.4    15 15  3  .  .  3  3  1  1  .   .  .   .
    Y.5    15 15  3  3  3  .  .  1  1  .   .  .   .
  
  
  We  see  that  the two approaches yield the same permutation characters, but
  the  two  lists are sorted in a different way. The latter is due to the fact
  that  the  rows  of  the  table  of  marks  are ordered in a way that is not
  compatible  with  the ordering of maximal subgroups for the character table.
  Moreover,  there  is no way to choose the fusion from the character table to
  the  table  of  marks  in  such  a  way  that  the  two lists of permutation
  characters would become equal. The component perm in the FusionToTom (3.2-4)
  record of the character table describes the incompatibility.
  
    Example  
    gap> FusionToTom( tbl );
    rec( map := [ 1, 2, 5, 4, 8, 3, 7, 11, 11, 6, 13, 6, 13 ], 
      name := "2.A6", perm := (4,5), 
      text := "fusion map is unique up to table autom." )
  
  
  
  2.3-6 Example: A Permutation Character of Fi_23
  
  Let  x  be  a 3B element in the sporadic simple Fischer group G = Fi_23. The
  normalizer   M   of   x   in   G   is   a   maximal  subgroup  of  the  type
  3^{1+8}_+.2^{1+6}_-.3^{1+2}_+.2S_4. We are interested in the distribution of
  the  elements  of  the  normal  subgroup N of the type 3^{1+8}_+ in M to the
  conjugacy classes of G.
  
  This  information  can be computed from the permutation character π = 1_N^G,
  so  we try to compute this permutation character. We have π = (1_N^M)^G, and
  1_N^M  can  be  computed  as  the  inflation of the regular character of the
  factor  group  M/N  to  M.  Note  that  the  character tables of G and M are
  available,  as well as the class fusion of M in G, and that N is the largest
  normal 3-subgroup of M.
  
    Example  
    gap> t:= CharacterTable( "Fi23" );
    CharacterTable( "Fi23" )
    gap> mx:= Maxes( t );
    [ "2.Fi22", "O8+(3).3.2", "2^2.U6(2).2", "S8(2)", "S3xO7(3)", 
      "2..11.m23", "3^(1+8).2^(1+6).3^(1+2).2S4", "Fi23M8", "A12.2", 
      "(2^2x2^(1+8)).(3xU4(2)).2", "2^(6+8):(A7xS3)", "S4xS6(2)", 
      "S4(4).4", "L2(23)" ]
    gap> m:= CharacterTable( mx[7] );
    CharacterTable( "3^(1+8).2^(1+6).3^(1+2).2S4" )
    gap> n:= ClassPositionsOfPCore( m, 3 );
    [ 1 .. 6 ]
    gap> f:= m / n;
    CharacterTable( "3^(1+8).2^(1+6).3^(1+2).2S4/[ 1, 2, 3, 4, 5, 6 ]" )
    gap> reg:= 0 * [ 1 .. NrConjugacyClasses( f ) ];;
    gap> reg[1]:= Size( f );;
    gap> infl:= reg{ GetFusionMap( m, f ) };
    [ 165888, 165888, 165888, 165888, 165888, 165888, 0, 0, 0, 0, 0, 0, 
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
    gap> ind:= Induced( m, t, [ infl ] );
    [ ClassFunction( CharacterTable( "Fi23" ),
      [ 207766624665600, 0, 0, 0, 603832320, 127567872, 6635520, 663552, 
          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
          0, 0, 0, 0, 0, 0 ] ) ]
    gap> PermCharInfo( t, ind ).contained;
    [ [ 1, 0, 0, 0, 864, 1538, 3456, 13824, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ]
    gap> PositionsProperty( OrdersClassRepresentatives( t ), x -> x = 3 );
    [ 5, 6, 7, 8 ]
  
  
  Thus N contains 864 elements in the class 3A, 1538 elements in the class 3B,
  and so on.
  
  
  2.3-7 Example: Non-commutators in the commutator group
  
  In general, not every element in the commutator group of a group is itself a
  commutator.  Are  there examples in the Character Table Library, and if yes,
  what is a smallest one?
  
    Example  
    gap> nam:= OneCharacterTableName( CommutatorLength, x -> x > 1
    >                                 : OrderedBy:= Size );
    "3.(A4x3):2"
    gap> Size( CharacterTable( nam ) );
    216
  
  
  The smallest groups with this property have order 96.
  
    Example  
    gap> OneSmallGroup( Size, [ 2 .. 100 ],
    >                   G -> CommutatorLength( G ) > 1, true );
    <pc group of size 96 with 6 generators>
  
  
  (Note the different syntax: OneSmallGroup (smallgrp: OneSmallGroup) does not
  admit a function such as x -> x > 1 for describing the admissible values.)
  
  Nonabelian  simple groups cannot be expected to have non-commutators, by the
  main theorem in [LOST10].
  
    Example  
    gap> OneCharacterTableName( IsSimple, true, IsAbelian, false,
    >                           IsDuplicateTable, false,
    >                           CommutatorLength, x -> x > 1
    >                           : OrderedBy:= Size );
    fail
  
  
  Perfect groups can contain non-commutators.
  
    Example  
    gap> nam:= OneCharacterTableName( IsPerfect, true,
    >                                 IsDuplicateTable, false,
    >                                 CommutatorLength, x -> x > 1
    >                                 : OrderedBy:= Size );
    "P1/G1/L1/V1/ext2"
    gap> Size( CharacterTable( nam ) );
    960
  
  
  This  is  in  fact  the  smallest  example  of a perfect group that contains
  non-commutators.
  
    Example  
    gap> for n in [ 2 .. 960 ] do
    >      for i in [ 1 .. NrPerfectGroups( n ) ] do
    >        g:= PerfectGroup( n,  i);
    >        if CommutatorLength( g ) <> 1 then
    >          Print( [ n, i ], "\n" );
    >        fi;
    >      od;
    >    od;
    [ 960, 2 ]
  
  
  
  2.3-8 Example: An irreducible 11-modular character of J_4 (December 2018)
  
  Let  G  be the sporadic simple Janko group J_4. For the ordinary irreducible
  characters  of  degree  1333  of G, the reductions modulo 11 are known to be
  irreducible Brauer characters.
  
  David Craven asked Richard Parker how to show that the antisymmetric squares
  of these Brauer characters are irreducible. Richard proposed the following.
  
  Restrict  the  given ordinary character [122χX, say, to a subgroup S of J_4 whose
  11-modular  character  table  is  known,  decompose the restriction χ_S into
  irreducible  Brauer  characters,  and  compute  those  constituents that are
  constant on all subsets of conjugacy classes that fuse in J_4. If the Brauer
  character χ_S cannot be written as a sum of two such constituents then [122χX, as
  a Brauer character of J_4, is irreducible.
  
  Here is a GAP session that shows how to apply this idea.
  
  The  group  J_4  has  exactly  two ordinary irreducible characters of degree
  1333.  They  are  complex conjugate, and so are their antisymmetric squares.
  Thus we may consider just one of the two.
  
    Example  
    gap> t:= CharacterTable( "J4" );;
    gap> deg1333:= Filtered( Irr( t ), x -> x[1] = 1333 );;
    gap> antisym:= AntiSymmetricParts( t, deg1333, 2 );;
    gap> List(  antisym, x -> Position( Irr( t ), x ) );
    [ 7, 6 ]
    gap> ComplexConjugate( antisym[1] ) = antisym[2];
    true
    gap> chi:= antisym[1];;  chi[1];
    887778
  
  
  Let  S be a maximal subgroup of the structure 2^11:M_24 in J_4. Fortunately,
  the 11-modular character table of S is available (it had been constructed by
  Christoph  Jansen),  and  we  can restrict the interesting character to this
  table.
  
    Example  
    gap> s:= CharacterTable( Maxes( t )[1] );;
    gap> Size( s ) = 2^11 * Size( CharacterTable( "M24" ) );
    true
    gap> rest:= RestrictedClassFunction( chi, s );;
    gap> smod11:= s mod 11;;
    gap> rest:= RestrictedClassFunction( rest, smod11 );;
  
  
  The  restriction  is  a  sum  of  nine pairwise different irreducible Brauer
  characters of S.
  
    Example  
    gap> dec:= Decomposition( Irr( smod11 ), [ rest ], "nonnegative" )[1];;
    gap> Sum( dec );
    9
    gap> constpos:= PositionsProperty( dec, x -> x <> 0 );
    [ 15, 36, 46, 53, 55, 58, 63, 67, 69 ]
  
  
  Next we compute those sets of classes of S which fuse in J_4.
  
    Example  
    gap> smod11fuss:= GetFusionMap( smod11, s );;
    gap> sfust:= GetFusionMap( s, t );;
    gap> fus:= CompositionMaps( sfust, smod11fuss );;
    gap> inv:= Filtered( InverseMap( fus ), IsList );
    [ [ 3, 4, 5 ], [ 2, 6, 7 ], [ 8, 9 ], [ 10, 11, 16 ], 
      [ 12, 14, 15, 17, 18, 21 ], [ 13, 19, 20, 22 ], [ 26, 27, 28, 30 ], 
      [ 25, 29, 31 ], [ 34, 39 ], [ 35, 37, 38 ], [ 40, 42 ], [ 41, 43 ], 
      [ 44, 47, 48 ], [ 45, 49, 50 ], [ 46, 51 ], [ 56, 57 ], [ 63, 64 ], 
      [ 69, 70 ] ]
  
  
  Finally, we run over all 2^9 subsets of the irreducible constituents.
  
    Example  
    gap> const:= Irr( smod11 ){ constpos };;
    gap> zero:= 0 * TrivialCharacter( smod11 );;
    gap> comb:= List( Combinations( const ), x -> Sum( x, zero ) );;
    gap> cand:= Filtered( comb,
    >               x -> ForAll( inv, l -> Length( Set( x{ l } ) ) = 1 ) );;
    gap> List( cand, x -> x[1] );
    [ 0, 887778 ]
  
  
  We  see  that no proper subset of the constituents yields a Brauer character
  that can be restricted from J_4.
  
  
  2.3-9  Example:  Tensor  Products  that are Generalized Projectives (October
  2019)
  
  Let  G  be a finite group and p be a prime integer. If the tensor product [122ΦX,
  say,  of two ordinary irreducible characters of G vanishes on all p-singular
  elements   of  G  then  [122ΦX  is  a  [122ℤX-linear  combination  of  the  projective
  indecomposable  characters Φ_φ = ∑_{χ ∈ Irr(G)} d_{χ φ} [122χX of G, where [122φX runs
  over  the  irreducible  p-modular  Brauer characters of G and d_{χ φ} is the
  decomposition  number  of [122χX and [122φX. (See for example [Nav98, p. 25] or [LP10,
  Def.  4.3.1].)  Such  class  functions  are  called  generalized  projective
  characters.
  
  In  fact,  very often [122ΦX is a projective character, that is, the coefficients
  of   the   decomposition   into  projective  indecomposable  characters  are
  nonnegative.
  
  We are interested in examples where this is not the case. For that, we write
  a  small  GAP function that computes, for a given p-modular character table,
  those   tensor   products   of  ordinary  irreducible  characters  that  are
  generalized projective characters but are not projective.
  
  Many  years  ago, Richard Parker had been interested in the question whether
  such  tensor  products can exist for a given group. Note that forming tensor
  products  that  vanish  on  p-singular  elements  is  a  recipe for creating
  projective  characters,  provided  one  knows  in advance that the answer is
  negative for the given group.
  
    Example  
    gap> GenProjNotProj:= function( modtbl )
    >      local p, tbl, X, PIMs, n, psingular, list, labels, i, j, psi,
    >            pos, dec, poss;
    > 
    >      p:= UnderlyingCharacteristic( modtbl );
    >      tbl:= OrdinaryCharacterTable( modtbl );
    >      X:= Irr( tbl );
    >      PIMs:= TransposedMat( DecompositionMatrix( modtbl ) ) * X;
    >      n:= Length( X );
    >      psingular:= Difference( [ 1 .. n ], GetFusionMap( modtbl, tbl ) );
    >      list:= [];
    >      labels:= [];
    >      for i in [ 1 .. n ] do
    >        for j in [ 1 .. i ] do
    >          psi:= List( [ 1 .. n ], x -> X[i][x] * X[j][x] );
    >          if IsZero( psi{ psingular } ) then
    >            # This is a generalized projective character.
    >            pos:= Position( list, psi );
    >            if pos = fail then
    >              Add( list, psi );
    >              Add( labels, [ [ j, i ] ] );
    >            else
    >              Add( labels[ pos ], [ j, i ] );
    >            fi;
    >          fi;
    >        od;
    >      od;
    > 
    >      if Length( list ) > 0 then
    >        # Decompose the generalized projective tensor products
    >        # into the projective indecomposables.
    >        dec:= Decomposition( PIMs, list, "nonnegative" );
    >        poss:= Positions( dec, fail );
    >        return Set( Concatenation( labels{ poss } ) );
    >      else
    >        return [];
    >      fi;
    >      end;;
  
  
  One  group  for which the function returns a nonempty result is the sporadic
  simple Janko group J_2 in characteristic 2.
  
    Example  
    gap> tbl:= CharacterTable( "J2" );;
    gap> modtbl:= tbl mod 2;;
    gap> pairs:= GenProjNotProj( modtbl );
    [ [ 6, 12 ] ]
    gap> irr:= Irr( tbl );;
    gap> PIMs:= TransposedMat( DecompositionMatrix( modtbl ) ) * irr;;
    gap> SolutionMat( PIMs, irr[6] * irr[12] );
    [ 0, 0, 0, 1, 1, 1, 0, 0, -2, 3 ]
  
  
  Checking  all  available  tables from the library takes several hours of CPU
  time  and  also  requires  a  lot of space; finally, it yields the following
  result.
  
    Example  
    gap> examples:= [];;
    gap> for name in AllCharacterTableNames( IsDuplicateTable, false ) do
    >      tbl:= CharacterTable( name );
    >      for p in PrimeDivisors( Size( tbl ) ) do
    >        modtbl:= tbl mod p;
    >        if modtbl <> fail then
    >          res:= GenProjNotProj( modtbl );
    >          if not IsEmpty( res ) then
    >            AddSet( examples, [ name, p, Length( res ) ] );
    >         fi;
    >       fi;
    >     od;
    >   od;
    gap> examples;
    [ [ "(A5xJ2):2", 2, 4 ], [ "(D10xJ2).2", 2, 9 ], [ "2.Suz", 3, 1 ], 
      [ "2.Suz.2", 3, 4 ], [ "2xCo2", 5, 4 ], [ "3.Suz", 2, 6 ], 
      [ "3.Suz.2", 2, 4 ], [ "Co2", 5, 1 ], [ "Co3", 2, 4 ], 
      [ "Isoclinic(2.Suz.2)", 3, 4 ], [ "J2", 2, 1 ], [ "Suz", 2, 2 ], 
      [ "Suz", 3, 1 ], [ "Suz.2", 3, 4 ] ]
  
  
  This  list  looks  rather sporadic. The number of examples is small, and all
  groups  in question except two (the subdirect products of S_5 and J_2.2, and
  of 5:4 and J_2.2, respectively) are extensions of sporadic simple groups.
  
  Note  that  the  following  cases could be omitted because the characters in
  question belong to proper factor groups: 2.Suz mod 3, 2.Suz.2 mod 3, and its
  isoclinic variant.
  
  
  2.3-10  Example:  Certain elementary abelian subgroups in quasisimple groups
  (November 2020)
  
  In  October 2020, Bob Guralnick asked: Does each quasisimple group G contain
  an  elementary  abelian  subgroup  that contains elements from all conjugacy
  classes  of involutions in G? (Such a subgroup is called a broad subgroup of
  G. See [GR] for the paper.)
  
  In the case of simple groups, theoretical arguments suffice to show that the
  answer  is  positive  for simple groups of alternating and Lie type, thus it
  remains to inspect the sporadic simple groups.
  
  In  the case of nonsimple quasisimple groups, again groups having a sporadic
  simple  factor  group have to be checked, and also the central extensions of
  groups   of   Lie  type  by  exceptional  multipliers  have  to  be  checked
  computationally.
  
  In the following situations, the answer is positive for a given group G.
  
  1   G has at most two classes of involutions. (Take an involution x in the
        centre  of a Sylow 2-subgroup P of G; if there is a conjugacy class of
        involutions  in G different from x^G then P contains an element in the
        other involution class.)
  
  2   G  has  exactly  three  classes  of  involutions  such  that there are
        representatives  x, y, z with the property x y = z. (The subgroup ⟨ x,
        y  [122⟩X  is  a Klein four group; note that x and y commute because x^{-1}
        y^{-1} x y = (x y)^2 = z^2 = 1 holds.)
  
  3   G  has  a  central  elementary  abelian  2-subgroup N, and there is an
        elementary  abelian 2-subgroup P / N in G / N containing elements from
        all  those  involution classes of G / N that lift to involutions of G,
        but no elements from other involution classes of G / N. (Just take the
        preimage P, which is elementary abelian.)
  
        This  condition is satisfied for example if the answer is positive for
        G  /  N  and  all involutions of G / N lift to involutions in G, or if
        exactly one class of involutions of G / N lifts to involutions in G.
  
  The  following  function  evaluates  the first two of the above criteria and
  easy cases of the third one, for the given character table of the group G.
  
    Example  
    gap> ApplyCriteria:= "dummy";;  # Avoid a syntax error ...
    gap> ApplyCriteria:= function( tbl )
    >    local id, ord, invpos, cen, facttbl, factfus, invmap, factord,
    >           factinvpos, imgs;
    >    id:= ReplacedString( Identifier( tbl ), " ", "" );
    >    ord:= OrdersClassRepresentatives( tbl );
    >    invpos:= PositionsProperty( ord, x -> x <= 2 );
    >    if Length( invpos ) <= 3 then
    >      # There are at most 2 involution classes.
    >      Print( "#I  ", id, ": ",
    >             "done (", Length( invpos ) - 1, " inv. class(es))\n" );
    >      return true;
    >    elif Length( invpos ) = 4 and
    >         ClassMultiplicationCoefficient( tbl, invpos[2], invpos[3],
    >                                              invpos[4] ) <> 0 then
    >      Print( "#I  ", id, ": ",
    >             "done (3 inv. classes, nonzero str. const.)\n" );
    >      return true;
    >    fi;
    >    cen:= Intersection( invpos, ClassPositionsOfCentre( tbl ) );
    >    if Length( cen ) > 1 then
    >      # Consider the factor modulo the largest central el. ab. 2-group.
    >      facttbl:= tbl / cen;
    >      factfus:= GetFusionMap( tbl, facttbl );
    >      invmap:= InverseMap( factfus );
    >      factord:= OrdersClassRepresentatives( facttbl );
    >      factinvpos:= PositionsProperty( factord, x -> x <= 2 );
    >      if ForAll( factinvpos,
    >             i -> invmap[i] in invpos or
    >                  ( IsList( invmap[i] ) and
    >                    IsSubset( invpos, invmap[i] ) ) ) then
    >        # All involutions of the factor group lift to involutions.
    >        if ApplyCriteria( facttbl ) = true then
    >          Print( "#I  ", id, ": ",
    >                 "done (all inv. in ",
    >                 ReplacedString( Identifier( facttbl ), " ", "" ),
    >                 " lift to inv.)\n" );
    >          return true;
    >        fi;
    >      fi;
    >      imgs:= Set( factfus{ invpos } );
    >      if Length( imgs ) = 2 and
    >         ForAll( imgs,
    >             i -> invmap[i] in invpos or
    >                  ( IsList( invmap[i] ) and
    >                    IsSubset( invpos, invmap[i] ) ) ) then
    >        # There is a C2 subgroup of the factor
    >        # such that its involution lifts to involutions,
    >        # and the lifts of the C2 cover all involution classes of 'tbl'.
    >        Print( "#I  ", id, ": ",
    >               "done (all inv. in ", id,
    >               " are lifts of a C2\n",
    >               "#I  in the factor modulo ",
    >               ReplacedString( String( cen ), " ", "" ), ")\n" );
    >        return true;
    >      fi;
    >    fi;
    >    Print( "#I  ", id, ": ",
    >           "OPEN (", Length( invpos  ) - 1, " inv. class(es))\n" );
    >    return false;
    > end;;
  
  
  We start with the sporadic simple groups.
  
    Example  
    gap> SizeScreen( [ 72 ] );;
    gap> spor:= AllCharacterTableNames( IsSporadicSimple, true,
    >                                   IsDuplicateTable, false );
    [ "B", "Co1", "Co2", "Co3", "F3+", "Fi22", "Fi23", "HN", "HS", "He", 
      "J1", "J2", "J3", "J4", "Ly", "M", "M11", "M12", "M22", "M23", 
      "M24", "McL", "ON", "Ru", "Suz", "Th" ]
    gap> Filtered( spor,
    >        x -> not ApplyCriteria( CharacterTable( x ) ) );
    #I  B: OPEN (4 inv. class(es))
    #I  Co1: OPEN (3 inv. class(es))
    #I  Co2: done (3 inv. classes, nonzero str. const.)
    #I  Co3: done (2 inv. class(es))
    #I  F3+: done (2 inv. class(es))
    #I  Fi22: done (3 inv. classes, nonzero str. const.)
    #I  Fi23: done (3 inv. classes, nonzero str. const.)
    #I  HN: done (2 inv. class(es))
    #I  HS: done (2 inv. class(es))
    #I  He: done (2 inv. class(es))
    #I  J1: done (1 inv. class(es))
    #I  J2: done (2 inv. class(es))
    #I  J3: done (1 inv. class(es))
    #I  J4: done (2 inv. class(es))
    #I  Ly: done (1 inv. class(es))
    #I  M: done (2 inv. class(es))
    #I  M11: done (1 inv. class(es))
    #I  M12: done (2 inv. class(es))
    #I  M22: done (1 inv. class(es))
    #I  M23: done (1 inv. class(es))
    #I  M24: done (2 inv. class(es))
    #I  McL: done (1 inv. class(es))
    #I  ON: done (1 inv. class(es))
    #I  Ru: done (2 inv. class(es))
    #I  Suz: done (2 inv. class(es))
    #I  Th: done (1 inv. class(es))
    [ "B", "Co1" ]
  
  
  The two open cases can be handled as follows.
  
  The  group  G  =  B  contains  maximal subgroups of the type 5:4 × HS.2 (the
  normalizers  of  5A  elements,  see [CCN+85, p. 217]). The direct factor H =
  HS.2  of  such a subgroup has four classes of involutions, which fuse to the
  four involution classes of G.
  
    Example  
    gap> t:= CharacterTable( "B" );;
    gap> invpos:= Positions( OrdersClassRepresentatives( t ), 2 );
    [ 2, 3, 4, 5 ]
    gap> mx:= List( Maxes( t ), CharacterTable );;
    gap> s:= First( mx,
    >          x -> Size( x ) = 20 * Size( CharacterTable( "HS.2" ) ) );
    CharacterTable( "5:4xHS.2" )
    gap> fus:= GetFusionMap( s, t );;
    gap> prod:= ClassPositionsOfDirectProductDecompositions( s );
    [ [ [ 1, 40 .. 157 ], [ 1 .. 39 ] ] ]
    gap> fusinB:= List( prod[1], l -> fus{ l } );
    [ [ 1, 18, 8, 3, 8 ], 
      [ 1, 3, 4, 6, 8, 9, 14, 19, 18, 18, 25, 22, 31, 36, 43, 51, 50, 54, 
          57, 81, 100, 2, 5, 8, 11, 16, 21, 20, 24, 34, 33, 48, 52, 59, 
          76, 106, 100, 100, 137 ] ]
    gap> IsSubset( fusinB[2], invpos );
    true
    gap> h:= CharacterTable( "HS.2" );;
    gap> fusinB[2]{ Positions( OrdersClassRepresentatives( h ), 2 ) };
    [ 3, 4, 2, 5 ]
  
  
  The table of marks of H is known. We find five classes of elementary abelian
  subgroups of order eight in H that contain elements from all four involution
  classes of H.
  
    Example  
    gap> tom:= TableOfMarks( h );
    TableOfMarks( "HS.2" )
    gap> ord:= OrdersTom( tom );;
    gap> invpos:= Positions( ord, 2 );
    [ 2, 3, 534, 535 ]
    gap> 8pos:= Positions( ord, 8 );;
    gap> filt:= Filtered( 8pos,
    >        x -> ForAll( invpos,
    >               y -> Length( IntersectionsTom( tom, x, y ) ) >= y
    >                    and IntersectionsTom( tom, x, y )[y] <> 0 ) );
    [ 587, 589, 590, 593, 595 ]
    gap> reps:= List( filt, i -> RepresentativeTom( tom, i ) );;
    gap> ForAll( reps, IsElementaryAbelian );
    true
  
  
  The  group G = Co_1 has a maximal subgroup H of type A_9 × S_3 (see [CCN+85,
  p. 183])  that  contains  elements  from  all three involution classes of G.
  Moreover,  the  factor S_3 contains 2A elements, and the factor A_9 contains
  2B  and  2C elements. This yields the desired elementary abelian subgroup of
  order eight.
  
    Example  
    gap> t:= CharacterTable( "Co1" );;
    gap> invpos:= Positions( OrdersClassRepresentatives( t ), 2 );
    [ 2, 3, 4 ]
    gap> mx:= List( Maxes( t ), CharacterTable );;
    gap> s:= First( mx, x -> Size( x ) = 3 * Factorial( 9 ) );
    CharacterTable( "A9xS3" )
    gap> fus:= GetFusionMap( s, t );;
    gap> prod:= ClassPositionsOfDirectProductDecompositions( s );
    [ [ [ 1 .. 3 ], [ 1, 4 .. 52 ] ] ]
    gap> List( prod[1], l -> fus{ l } );
    [ [ 1, 8, 2 ], 
      [ 1, 3, 4, 5, 7, 6, 13, 14, 15, 19, 24, 28, 36, 37, 39, 50, 61, 61 
         ] ]
  
  
  Thus  we  know  that  the answer is positive for each sporadic simple group.
  Next  we look at the relevant covering groups of sporadic simple groups. For
  a  quasisimple group with a sporadic simple factor, the Schur multiplier has
  at  most  the prime factors 2 and 3; only the extension by the 2-part of the
  multipier must be checked.
  
    Example  
    gap> sporcov:= AllCharacterTableNames( IsSporadicSimple, true,
    >        IsDuplicateTable, false, OfThose, SchurCover );
    [ "12.M22", "2.B", "2.Co1", "2.HS", "2.J2", "2.M12", "2.Ru", "3.F3+", 
      "3.J3", "3.McL", "3.ON", "6.Fi22", "6.Suz", "Co2", "Co3", "Fi23", 
      "HN", "He", "J1", "J4", "Ly", "M", "M11", "M23", "M24", "Th" ]
    gap> Filtered( sporcov, x -> '.' in x );
    [ "12.M22", "2.B", "2.Co1", "2.HS", "2.J2", "2.M12", "2.Ru", "3.F3+", 
      "3.J3", "3.McL", "3.ON", "6.Fi22", "6.Suz" ]
    gap> relevant:= [ "2.M22", "4.M22", "2.B", "2.Co1", "2.HS", "2.J2",
    >                 "2.M12", "2.Ru", "2.Fi22", "2.Suz" ];;
    gap> Filtered( relevant,
    >        x -> not ApplyCriteria( CharacterTable( x ) ) );
    #I  2.M22: done (3 inv. classes, nonzero str. const.)
    #I  4.M22: done (2 inv. class(es))
    #I  2.B: OPEN (5 inv. class(es))
    #I  2.Co1: OPEN (4 inv. class(es))
    #I  2.HS: done (3 inv. classes, nonzero str. const.)
    #I  2.J2: done (3 inv. classes, nonzero str. const.)
    #I  2.M12: done (3 inv. classes, nonzero str. const.)
    #I  2.Ru: done (3 inv. classes, nonzero str. const.)
    #I  2.Fi22/[1,2]: done (3 inv. classes, nonzero str. const.)
    #I  2.Fi22: done (all inv. in 2.Fi22/[1,2] lift to inv.)
    #I  2.Suz: done (3 inv. classes, nonzero str. const.)
    [ "2.B", "2.Co1" ]
  
  
  The  group  B  has four classes of involutions, let us call them 2A, 2B, 2C,
  and 2D. All except 2C lift to involutions in 2.B.
  
    Example  
    gap> t:= CharacterTable( "B" );;
    gap> 2t:= CharacterTable( "2.B" );;
    gap> invpost:= Positions( OrdersClassRepresentatives( t ), 2 );
    [ 2, 3, 4, 5 ]
    gap> invpos2t:= Positions( OrdersClassRepresentatives( 2t ), 2 );
    [ 2, 3, 4, 5, 7 ]
    gap> GetFusionMap( 2t, t ){ invpos2t };
    [ 1, 2, 3, 3, 5 ]
  
  
  Thus  it  suffices  to  show  that there is a subgroup of type 2^2 in B that
  contains elements from 2A, 2B, and 2D (but no element from 2C). This follows
  from the fact that the (2A, 2B, 2D) structure constant of B is nonzero.
  
    Example  
    gap> ClassMultiplicationCoefficient( t, 2, 3, 5 );
    120
  
  
  The  group  Co_1  has three classes of involutions, let us call them 2A, 2B,
  and 2C. All except 2B lift to involutions in 2.Co_1.
  
    Example  
    gap> t:= CharacterTable( "Co1" );;
    gap> 2t:= CharacterTable( "2.Co1" );;
    gap> invpost:= Positions( OrdersClassRepresentatives( t ), 2 );
    [ 2, 3, 4 ]
    gap> invpos2t:= Positions( OrdersClassRepresentatives( 2t ), 2 );
    [ 2, 3, 4, 6 ]
    gap> GetFusionMap( 2t, t ){ invpos2t };
    [ 1, 2, 2, 4 ]
  
  
  Thus  it  suffices to show that there is a subgroup of type 2^2 in Co_1 that
  contains  elements  from 2A and 2C but no element from 2B. This follows from
  the fact that the (2A, 2A, 2C) structure constant of Co_1 is nonzero.
  
    Example  
    gap> ClassMultiplicationCoefficient( t, 2, 2, 4 );
    264
  
  
  Finally,  we  deal  with  the  relevant  central extensions of finite simple
  groups  of Lie type with exceptional multipliers. These groups are listed in
  [CCN+85,  p. xvi,  Table  5].  The  following  cases  belong  to exceptional
  multipliers with nontrivial 2-part.
  
      ┌─────────────────┬──────────┬────────────┐
      │ Group           │ Name     │ Multiplier │ 
      ├─────────────────┼──────────┼────────────┤
      │ A_1(4)          │ "A5"     │          2 │ 
      │ A_2(2)          │ "L3(2)"  │          2 │ 
      │ A_2(4)          │ "L3(4)"  │        4^2 │ 
      │ A_3(2)          │ "A8"     │          2 │ 
      │ ^2A_3(2)        │ "U4(2)"  │          2 │ 
      │ ^2A_5(2)        │ "U6(2)"  │        2^2 │ 
      │ B_2(2)          │ "S6"     │          2 │ 
      │ ^2B_2(2)        │ "Sz(8)"  │        2^2 │ 
      │ B_3(2) ≅ C_3(2) │ "S6(2)"  │          2 │ 
      │ D_4(2)          │ "O8+(2)" │        2^2 │ 
      │ G_2(4)          │ "G2(4)"  │          2 │ 
      │ F_4(2)          │ "F4(2)"  │          2 │ 
      │ ^2E_6(2)        │ "2E6(2)" │        2^2 │ 
      └─────────────────┴──────────┴────────────┘
  
       Table: Groups with exceptional 2-part of their multiplier
  
  
  This  leads to the following list of cases to be checked. (We would not need
  to  deal with the groups A_5 and L_3(2), because of isomorphisms with groups
  of  Lie  type  for  which the multiplier in question is not exceptional, but
  here we ignore this fact.)
  
    Example  
    gap> list:= [
    >      [ "A5", "2.A5" ],
    >      [ "L3(2)", "2.L3(2)" ],
    >      [ "L3(4)", "2.L3(4)", "2^2.L3(4)", "4_1.L3(4)", "4_2.L3(4)",
    >        "(2x4).L3(4)", "4^2.L3(4)" ],
    >      [ "A8", "2.A8" ],
    >      [ "U4(2)", "2.U4(2)"],
    >      [ "U6(2)", "2.U6(2)", "2^2.U6(2)" ],
    >      [ "A6", "2.A6" ],
    >      [ "Sz(8)", "2.Sz(8)", "2^2.Sz(8)" ],
    >      [ "S6(2)", "2.S6(2)" ],
    >      [ "O8+(2)", "2.O8+(2)", "2^2.O8+(2)" ],
    >      [ "G2(4)", "2.G2(4)" ],
    >      [ "F4(2)", "2.F4(2)" ],
    >      [ "2E6(2)", "2.2E6(2)", "2^2.2E6(2)" ] ];;
    gap> Filtered( Concatenation( list ),
    >        x -> not ApplyCriteria( CharacterTable( x ) ) );
    #I  A5: done (1 inv. class(es))
    #I  2.A5: done (1 inv. class(es))
    #I  L3(2): done (1 inv. class(es))
    #I  2.L3(2): done (1 inv. class(es))
    #I  L3(4): done (1 inv. class(es))
    #I  2.L3(4): done (3 inv. classes, nonzero str. const.)
    #I  2^2.L3(4)/[1,2,3,4]: done (1 inv. class(es))
    #I  2^2.L3(4): done (all inv. in 2^2.L3(4)/[1,2,3,4] lift to inv.)
    #I  4_1.L3(4): done (2 inv. class(es))
    #I  4_2.L3(4): done (2 inv. class(es))
    #I  (2x4).L3(4): done (all inv. in (2x4).L3(4) are lifts of a C2
    #I  in the factor modulo [1,2,3,4])
    #I  4^2.L3(4): done (all inv. in 4^2.L3(4) are lifts of a C2
    #I  in the factor modulo [1,2,3,4])
    #I  A8: done (2 inv. class(es))
    #I  2.A8: done (2 inv. class(es))
    #I  U4(2): done (2 inv. class(es))
    #I  2.U4(2): done (2 inv. class(es))
    #I  U6(2): done (3 inv. classes, nonzero str. const.)
    #I  2.U6(2)/[1,2]: done (3 inv. classes, nonzero str. const.)
    #I  2.U6(2): done (all inv. in 2.U6(2)/[1,2] lift to inv.)
    #I  2^2.U6(2)/[1,2,3,4]: done (3 inv. classes, nonzero str. const.)
    #I  2^2.U6(2): done (all inv. in 2^2.U6(2)/[1,2,3,4] lift to inv.)
    #I  A6: done (1 inv. class(es))
    #I  2.A6: done (1 inv. class(es))
    #I  Sz(8): done (1 inv. class(es))
    #I  2.Sz(8): done (2 inv. class(es))
    #I  2^2.Sz(8)/[1,2,3,4]: done (1 inv. class(es))
    #I  2^2.Sz(8): done (all inv. in 2^2.Sz(8)/[1,2,3,4] lift to inv.)
    #I  S6(2): OPEN (4 inv. class(es))
    #I  2.S6(2): OPEN (3 inv. class(es))
    #I  O8+(2): OPEN (5 inv. class(es))
    #I  2.O8+(2): OPEN (5 inv. class(es))
    #I  2^2.O8+(2): OPEN (5 inv. class(es))
    #I  G2(4): done (2 inv. class(es))
    #I  2.G2(4): done (3 inv. classes, nonzero str. const.)
    #I  F4(2): OPEN (4 inv. class(es))
    #I  2.F4(2)/[1,2]: OPEN (4 inv. class(es))
    #I  2.F4(2): OPEN (9 inv. class(es))
    #I  2E6(2): done (3 inv. classes, nonzero str. const.)
    #I  2.2E6(2)/[1,2]: done (3 inv. classes, nonzero str. const.)
    #I  2.2E6(2): done (all inv. in 2.2E6(2)/[1,2] lift to inv.)
    #I  2^2.2E6(2)/[1,2,3,4]: done (3 inv. classes, nonzero str. const.)
    #I  2^2.2E6(2): done (all inv. in 2^2.2E6(2)/[1,2,3,4] lift to inv.)
    [ "S6(2)", "2.S6(2)", "O8+(2)", "2.O8+(2)", "2^2.O8+(2)", "F4(2)", 
      "2.F4(2)" ]
  
  
  We  could  assume  that  the answer is positive for the simple groups in the
  list  of  open  cases, by theoretical arguments, but it is easy to show this
  computationally.
  
  For  G  =  S_6(2), consider a maximal subgroup 2^6.L_3(2) of G (see [CCN+85,
  p. 46]):  Its  2-core  is  elementary abelian and covers all four involution
  classes of G.
  
    Example  
    gap> t:= CharacterTable( "S6(2)" );;
    gap> invpos:= Positions( OrdersClassRepresentatives( t ), 2 );
    [ 2, 3, 4, 5 ]
    gap> mx:= List( Maxes( t ), CharacterTable );;
    gap> s:= First( mx,
    >          x -> Size( x ) = 2^6 * Size( CharacterTable( "L3(2)" ) ) );
    CharacterTable( "2^6:L3(2)" )
    gap> corepos:= ClassPositionsOfPCore( s, 2 );
    [ 1 .. 5 ]
    gap> OrdersClassRepresentatives( t ){ corepos };
    [ 1, 2, 2, 2, 2 ]
    gap> GetFusionMap( s, t ){ corepos };
    [ 1, 3, 4, 2, 5 ]
  
  
  Concerning  G  =  2.S_6(2),  note  that  from the four involution classes of
  S_6(2), exactly 2B and 2D lift to involutions in 2.S_6(2).
  
    Example  
    gap> 2t:= CharacterTable( "2.S6(2)" );;
    gap> invpost:= Positions( OrdersClassRepresentatives( t ), 2 );
    [ 2, 3, 4, 5 ]
    gap> invpos2t:= Positions( OrdersClassRepresentatives( 2t ), 2 );
    [ 2, 4, 6 ]
    gap> GetFusionMap( 2t, t ){ invpos2t };
    [ 1, 3, 5 ]
  
  
  Thus it suffices to show that there is a subgroup of type 2^2 in S_6(2) that
  contains elements from 2B and 2D but no elements from 2A or 2C. This follows
  from the fact that the (2B, 2D, 2D) structure constant of S_6(2) is nonzero.
  
    Example  
    gap> ClassMultiplicationCoefficient( t, 3, 5, 5 );
    15
  
  
  For G = O_8^+(2), we consider the known table of marks.
  
    Example  
    gap> t:= CharacterTable( "O8+(2)" );;
    gap> tom:= TableOfMarks( t );
    TableOfMarks( "O8+(2)" )
    gap> ord:= OrdersTom( tom );;
    gap> invpos:= Positions( ord, 2 );
    [ 2, 3, 4, 5, 6 ]
    gap> 8pos:= Positions( ord, 8 );;
    gap> filt:= Filtered( 8pos,
    >             x -> ForAll( invpos,
    >                    y -> Length( IntersectionsTom( tom, x, y ) ) >= y
    >                         and IntersectionsTom( tom, x, y )[y] <> 0 ) );
    [ 151, 153 ]
    gap> reps:= List( filt, i -> RepresentativeTom( tom, i ) );;
    gap> ForAll( reps, IsElementaryAbelian );
    true
  
  
  Concerning  G  =  2.O_8^+(2),  note that from the five involution classes of
  O_8^+(2), exactly 2A, 2B, and 2E lift to involutions in 2.O_8^+(2).
  
    Example  
    gap> 2t:= CharacterTable( "2.O8+(2)" );;
    gap> invpost:= Positions( OrdersClassRepresentatives( t ), 2 );
    [ 2, 3, 4, 5, 6 ]
    gap> invpos2t:= Positions( OrdersClassRepresentatives( 2t ), 2 );
    [ 2, 3, 4, 5, 8 ]
    gap> GetFusionMap( 2t, t ){ invpos2t };
    [ 1, 2, 3, 3, 6 ]
  
  
  Thus  it  suffices  to  show  that  the  (2A,  2B, 2E) structure constant of
  O_8^+(2) is nonzero.
  
    Example  
    gap> ClassMultiplicationCoefficient( t, 2, 3, 6 );
    4
  
  
  Concerning  G  = 2^2.O_8^+(2), note that from the five involution classes of
  O_8^+(2),   exactly   the   first  and  the  last  lift  to  involutions  in
  2^2.O_8^+(2).
  
    Example  
    gap> v4t:= CharacterTable( "2^2.O8+(2)" );;
    gap> invposv4t:= Positions( OrdersClassRepresentatives( v4t ), 2 );
    [ 2, 3, 4, 5, 12 ]
    gap> GetFusionMap( v4t, t ){ invposv4t };
    [ 1, 1, 1, 2, 6 ]
  
  
  Thus it suffices to show that a corresponding structure constant of O_8^+(2)
  is nonzero.
  
    Example  
    gap> ClassMultiplicationCoefficient( t, 2, 6, 6 );
    27
  
  
  For  G  = F_4(2), consider a maximal subgroup 2^10.A_8 of a maximal subgroup
  S_8(2) of G (see [CCN+85, p. 123 and 170]): Its 2-core is elementary abelian
  and covers all four involution classes of G.
  
    Example  
    gap> t:= CharacterTable( "F4(2)" );;
    gap> invpost:= Positions( OrdersClassRepresentatives( t ), 2 );
    [ 2, 3, 4, 5 ]
    gap> "S8(2)" in Maxes( t );
    true
    gap> s:= CharacterTable( "S8(2)M4" );
    CharacterTable( "2^10.A8" )
    gap> corepos:= ClassPositionsOfPCore( s, 2 );
    [ 1 .. 7 ]
    gap> OrdersClassRepresentatives( s ){ corepos };
    [ 1, 2, 2, 2, 2, 2, 2 ]
    gap> poss:= PossibleClassFusions( s, t );;
    gap> List( poss, map -> map{ corepos } );
    [ [ 1, 4, 2, 3, 4, 5, 5 ], [ 1, 4, 2, 3, 4, 5, 5 ], 
      [ 1, 4, 3, 2, 4, 5, 5 ], [ 1, 4, 3, 2, 4, 5, 5 ] ]
  
  
  Finally, all involutions of G lift to involutions in 2.F_4(2).
  
    Example  
    gap> 2t:= CharacterTable( "2.F4(2)" );;
    gap> invpos2t:= Positions( OrdersClassRepresentatives( 2t ), 2 );
    [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
    gap> GetFusionMap( 2t, t ){ invpos2t };
    [ 1, 2, 2, 3, 3, 4, 4, 5, 5 ]
  
  

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