GAP (CTblLib) - Chapter 2: Tutorial for the GAP Character Table Library

Goto Chapter: Top 1 2 3 4 5 6 7 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax on]

2 Tutorial for the GAP Character Table Library
2.1 Concepts used in the GAP Character Table Library
2.2 Accessing a Character Table from the Library
2.2-1 Accessing a Character Table via a name
2.2-2 Accessing a Character Table via properties
2.2-3 Accessing a Character Table via a Table of Marks
2.2-4 Accessing a Character Table relative to another Character Table
2.2-5 Different character tables for the same group
2.3 Examples of Using the GAP Character Table Library
2.3-1 Example: Ambivalent Simple Groups
2.3-2 Example: Simple p-pure Groups
2.3-3 Example: Simple Groups with only one p-Block
2.3-4 Example:The Sylow 3 subgroup of 3.O'N
2.3-5 Example: Primitive Permutation Characters of 2.A_6
2.3-6 Example: A Permutation Character of Fi_23
2.3-7 Example: Non-commutators in the commutator group
2.3-8 Example: An irreducible 11-modular character of J_4 (December 2018)
2.3-9 Example: Tensor Products that are Generalized Projectives (October 2019)
2.3-10 Example: Certain elementary abelian subgroups in quasisimple groups (November 2020)

### 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 2.1 and 2.2, Section 2.3 shows a few small examples.

In order to force that the output of the examples consists 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 support only ASCII characters.

    gap> origpref:= UserPreference( "AtlasRep", "DisplayFunction" );;
    gap> SetUserPreference( "AtlasRep", "DisplayFunction", "Print" );

Some of the examples need functionalities from other GAP packages in the sense that the output looks different if these packages are not available.

    gap> LoadPackage( "Browse", false );
    true
    gap> LoadPackage( "SpinSym", false );
    true
    gap> LoadPackage( "TomLib", false );
    true

#### 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.

    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.

    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 [MNP19] 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).

    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.

    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 id`M`i.

    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.

    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", "3^(2+5+10).(M11x2S4)",
      "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.

    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.

    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.

    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.

    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.

    gap> IsDuplicateTable( s2 );
    true
    gap> IdentifierOfMainTable( s2 );
    "M11"
    gap> IdentifiersOfDuplicateTables( s1 );
    [ "HSM9", "M12M2", "ONM11" ]

See Section 3.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.

    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.

    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?

    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]).

    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.

    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.

    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].

    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.

    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.

    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.

    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?

    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.

    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].

    gap> OneCharacterTableName( IsSimple, true, IsAbelian, false,
    >                           IsDuplicateTable, false,
    >                           CommutatorLength, x -> x > 1
    >                           : OrderedBy:= Size );
    fail

Perfect groups can contain non-commutators.

    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.

    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 χ, 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 χ, 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.

    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.

    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.

    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.

    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.

    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 Φ, say, of two ordinary irreducible characters of G vanishes on all p-singular elements of G then Φ is a ℤ-linear combination of the projective indecomposable characters Φ_φ = ∑_{χ ∈ Irr(G)} d_{χ φ} χ of G, where φ runs over the irreducible p-modular Brauer characters of G and d_{χ φ} is the decomposition number of χ and φ. (See for example [Nav98, p. 25] or [LP10, Def. 4.3.1].) Such class functions are called generalized projective characters.

In fact, very often Φ 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.

    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.

    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.

    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 ⟩ 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.

    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.

    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.

    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.

    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.

    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.

    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.

    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.

    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.

    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.

    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.

Table: Groups with exceptional 2-part of their multiplier
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

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.)

    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.

    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).

    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.

    gap> ClassMultiplicationCoefficient( t, 3, 5, 5 );
    15

For G = O_8^+(2), we consider the known table of marks.

    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).

    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.

    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).

    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.

    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.

    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).

    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 ]

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 Bib Ind

generated by GAPDoc2HTML