# GAP Computations Concerning Probabilistic Generation of Finite Simple Groups

### THOMAS BREUER
Lehrstuhl D für Mathematik
RWTH, 52056 Aachen, Germany

### March 28th, 2012

This is a collection of examples showing how the GAP system [GAP12] can be used to compute information about the probabilistic generation of finite almost simple groups. It includes all examples that were needed for the computational results in [BGK08].
The purpose of this writeup is twofold. On the one hand, the computations are documented this way. On the other hand, the GAP code shown for the examples can be used as test input for automatic checking of the data and the functions used.
A first version of this document, which was based on GAP 4.4.10, had been accessible in the web since April 2006 and is available in the arXiv (no. 0710.3267) since October 2007. The differences to the current version are as follows.

- The format of the GAP output was adjusted to the changed behaviour of GAP 4.5. This affects mainly the way how GAP records are printed.
- Several computations are now easier because more character tables of almost simple groups and maximal subgroups of such groups are available in the GAP Character Table Library. (The more involved computations from the original version have been kept in the file.)
- The computation of all conjugacy classes of a subgroup of PΩ+(12,3) has been replaced by the computation of the conjugacy classes of elements of prime order in this subgroup.
- The irreducible element chosen in the simple group PΩ−(10,3) has order 61 not 122.

# Contents

1 Overview
2 Prerequisites
2.1 Theoretical Background
2.2 Computational Criteria
3 GAP Functions for the Computations
3.1 General Utilities
3.2 Character-Theoretic Computations
3.3 Computations with Groups
4 Character-Theoretic Computations
4.1 Sporadic Simple Groups
4.2 Automorphism Groups of Sporadic Simple Groups
4.3 Other Simple Groups - Easy Cases
4.4 Automorphism Groups of other Simple Groups - Easy Cases
4.5 O8−(3)
4.6 O10+(2)
4.7 O10−(2)
4.8 O12+(2)
4.9 O12−(2)
4.10 S6(4)
4.11 ∗ S6(5)
4.12 S8(3)
4.13 U4(4)
4.14 U6(2)
5 Computations using Groups
5.1 A2m+1, 2 ≤ m ≤ 11
5.2 A5
5.3 A6
5.4 A7
5.5 Ld(q)
5.6 ∗ Ld(q) with prime d
5.7 Automorphic Extensions of Ld(q)
5.8 L3(2)
5.9 M11
5.10 M12
5.11 O7(3)
5.12 O8+(2)
5.13 O8+(3)
5.14 O+8(4)
5.15 ∗ O9(3)
5.16 O10−(3)
5.17 O14−(2)
5.18 O12+(3)
5.19 ∗ S4(8)
5.20 S6(2)
5.21 S8(2)
5.22 ∗ S10(2)
5.23 U4(2)
5.24 U4(3)
5.25 U6(3)
5.26 U8(2)

## 1 Overview

The main purpose of this note is to document the GAP computations that were carried out in order to obtain the computational results in [BGK08]. Table 1 lists the simple groups among these examples. The first column gives the group names, the second and third columns contain a plus sign + or a minus sign −, depending on whether the quantities σ(G,s) and P(G,s), respectively, are less than 1/3. The fourth column lists the orders of elements s which either prove the + signs or cover most of the cases for proving these signs. The fifth column lists the sections in this note where the example is treated. The rows of the table are ordered alphabetically w.r.t. the group names.
In order to keep this note self-contained, we first describe the theory needed, in Section 2. The translation of the relevant formulae into GAP functions can be found in Section 3. Then Section 4 describes the computations that only require (ordinary) character tables in the GAP Character Table Library [Bre12]. Computations using also the groups are shown in Section 5. In each of the last two sections, the examples are ordered alphabetically w.r.t. the names of the simple groups.
Table 1: Computations needed in [BGK08]

G | σ < [1/3] | P < [1/3] | |s| | see
A5 | − | − | 5 | 5.2
A6 | − | − | 4 | 5.3
A7 | − | − | 7 | 5.4
A8 | + |  | 15 | 4.3, 5.5
A9 | + |  | 9 | 4.3, 5.1
A11 | + |  | 11 | 4.3, 5.1
A13 | + |  | 13 | 4.3, 5.1
A15 | + |  | 15 | 5.1
A17 | + |  | 17 | 5.1
A19 | + |  | 19 | 5.1
A21 | + |  | 21 | 5.1
A23 | + |  | 23 | 5.1
L3(2) | + |  | 7 | 4.3, 4.4,
|  |  |  | 5.5, 5.8
L3(3) | + |  | 13 | 4.3, 4.4,
|  |  |  | 5.5
L3(4) | + |  | 7 | 4.3, 4.4
L4(3) | + |  | 20 | 4.3, 5.5
L4(4) | + |  | 85 | 5.5
L6(2) | + |  | 63 | 5.5
L6(3) | + |  | 182 | 5.5
L6(4) | + |  | 455 | 5.5
L6(5) | + |  | 1953 | 5.5
L8(2) | + |  | 255 | 5.5
L10(2) | + |  | 1023 | 5.5
M11 | − | − | 11 | 5.9
M12 | − | + | 10 | 4.2, 5.10

G | σ < [1/3] | P < [1/3] | |s| | see
O+8(2) | − | − | 15 | 5.12
O+8(3) | − | − | 20 | 5.13
O+8(4) | + |  | 65 | 5.14
O+10(2) | + |  | 45 | 4.6
O+12(2) | + |  | 85 | 4.8
O+12(3) | + |  | 205 | 5.18
O−8(2) | + |  | 17 | 4.3
O−8(3) | + |  | 41 | 4.5
O−10(2) | + |  | 33 | 4.7
O−10(3) | + |  | 122 | 5.16
O−12(2) | + |  | 65 | 4.9
O−14(2) | + |  | 129 | 5.17
O7(3) | − | − | 14 | 5.11
S4(4) | + |  | 17 | 4.3, 4.4
S6(2) | − | − | 9 | 5.20
S6(3) | + |  | 14 | 4.3, 4.4
S6(4) | + |  | 65 | 4.10
S8(2) | − | − | 17 | 5.21
S8(3) | + |  | 41 | 4.12
U3(3) | + |  | 6 | 4.3, 4.4
U3(5) | + |  | 10 | 4.3, 4.4
U4(2) | − | − | 9 | 5.23
U4(3) | − | + | 7 | 5.24
U4(4) | + |  | 65 | 4.13
U5(2) | + |  | 11 | 4.3
U6(2) | + |  | 11 | 4.14
U6(3) | + |  | 122 | 5.25
U8(2) | + |  | 129 | 5.26

Contrary to [BGK08], ATLAS notation is used throughout this note, because the identifiers used for character tables in the GAP Character Table Library follow mainly the ATLAS [CCN+85]. For example, we write Ld(q) for PSL(d,q), Sd(q) for PSp(d,q), Ud(q) for PSU(d,q), and O+2d(q), O−2d(q), O2d+1(q) for PΩ+(2d,q), PΩ−(2d,q), PΩ(2d+1,q), respectively.
Furthermore, in the case of classical groups, the character tables of the (almost) simple groups are considered not the tables of the matrix groups (which are in fact often not available in the GAP Character Table Library). Consequently, also element orders and the description of maximal subgroups refer to the (almost) simple groups not to the matrix groups.
This note contains also several examples that are not needed for the proofs in [BGK08]. Besides several small simple groups G whose character table is contained in the GAP Character Table Library and for which enough information is available for computing σ(G), in Section 4.3, a few such examples appear in individual sections. In the table of contents, the section headers of the latter kind of examples are marked with an asterisk (∗).
The examples use the GAP Character Table Library, the GAP Library of Tables of Marks, and the GAP interface [WPN+11] to the ATLAS of Group Representations [WWT+], so we first load these three packages in the required versions. The GAP output was adjusted to the versions shown below; in older versions, features necessary for the computations may be missing, and it may happen that newer versions, the behaviour is different.
Also, we force the assertion level to zero; this is the default in interactive GAP sessions but the level is automatically set to 1 when a file is read with `ReadTest`.

        gap> CompareVersionNumbers( GAPInfo.Version, "4.5.0" );
        true
        gap> LoadPackage( "ctbllib", "1.2" );
        true
        gap> LoadPackage( "tomlib", "1.2" );
        true
        gap> LoadPackage( "atlasrep", "1.5" );
        true
        gap> SetAssertionLevel( 0 );

Some of the computations in Section 5 require about 800 MB of space (on 32 bit machines). Therefore we check whether GAP was started with sufficient maximal memory; the command line option for this is `-o 800m`.

        gap> max:= GAPInfo.CommandLineOptions.o;;
        gap> IsSubset( max, "m" ) and Int( Filtered( max, IsDigitChar ) ) >= 800;
        true

Several computations involve calls to the GAP function `Random`. In order to make the results of individual examples reproducible, independent of the rest of the computations, we reset the relevant random number generators whenever this is appropriate. For that, we store the initial states in the variable `staterandom`, and provide a function for resetting the random number generators. (The `Random` calls in the GAP library use the two random number generators `GlobalRandomSource` and `GlobalMersenneTwister`.)

        gap> staterandom:= [ State( GlobalRandomSource ),
        >                    State( GlobalMersenneTwister ) ];;
        gap> ResetGlobalRandomNumberGenerators:= function()
        >     Reset( GlobalRandomSource, staterandom[1] );
        >     Reset( GlobalMersenneTwister, staterandom[2] );
        > end;;

## 2 Prerequisites

### 2.1 Theoretical Background

Let G be a finite group, S the socle of G, and denote by G× the set of nonidentity elements in G. For s, g ∈ G×, let P( g, s ): = |{ h ∈ G; S ⊄ eq 〈sh, g 〉}| / |G|, the proportion of elements in the class sG which fail to generate at least S with g; we set P( G, s ): = max{ P( g, s ); g ∈ G× }. We are interested in finding a class sG of elements in S such that P( G, s ) < 1/3 holds.
First consider g ∈ S, and let M(S,s) denote the set of those maximal subgroups of S that contain s. We have

|{ h ∈ S; S ⊄ eq 〈sh, g 〉}|

=

|{ h ∈ S; 〈s, h g h−1 〉 ≠ S }|

≤

| ∑ M ∈ M(S,s) | |{ h ∈ S; h g h−1 ∈ M }|

Since h g h−1 ∈ M holds if and only if the coset M h is fixed by g under the permutation action of S on the right cosets of M in S, we get that |{ h ∈ S; h g h−1 ∈ M }| = |CS(g)| ·|gS ∩M| = |M| ·1MS(g), where 1MS is the permutation character of this action, of degree |S|/|M|. Thus

|{ h ∈ S; 〈s, h g h−1 〉 ≠ S }| / |S|

≤

| ∑ M ∈ M(S,s) | 1MS(g) / 1MS(1) .

We abbreviate the right hand side of this inequality by σ( g, s ), set σ( S, s ): = max{ σ( g, s ); g ∈ S× }, and choose a transversal T of S in G. Then P( g, s ) ≤ |T|−1 ·∑t ∈ T σ( gt, s ) and thus P( G, s ) ≤ σ( S, s ) holds.
If S = G and if M(G,s) consists of a single maximal subgroup M of G then equality holds, i.e., P( g, s ) = σ( g, s ) = 1MS(g) / 1MS(1).
The quantity 1MS(g) / 1MS(1) = |gS ∩M| / |gS| is the proportion of fixed points of g in the permutation action of S on the right cosets of its subgroup M. This is called the fixed point ratio of g w. r. t. S/M, and is denoted as μ(g,S/M).
For a subgroup M of S, the number n of S-conjugates of M containing s is equal to |MS| ·|sS ∩M| / |sS|. To see this, consider the set { (sh, Mk); h, k ∈ S, sh ∈ Mk }, the cardinality of which can be counted either as |MS| ·|sS ∩M| or as |sS| ·n. So we get n = |M| ·1MS(s) / |NS(M)|.
If S is a finite nonabelian simple group then each maximal subgroup in S is self-normalizing, and we have n = 1MS(s) if M is maximal. So we can replace the summation over M(S,s) by one over a set M/ ∼ (S,s) of representatives of conjugacy classes of maximal subgroups of S, and get that

σ( g, s ) =

∑
M ∈ M/ ∼ (S,s)

1MS(s) ·1MS(g)

1MS(1)

.

Furthermore, we have |M(S,s)| = ∑M ∈ M/ ∼ (S,s) 1MS(s).
In the following, we will often deal with the quantities σ(S): = min{ σ( S, s ); s ∈ S× } and S(S): = 1 / σ(S) − 1 . These values can be computed easily from the primitive permutation characters of S.
Analogously, we set P(S): = min{ P( S, s ); s ∈ S× } and P(S): = 1 / P(S) − 1 . Clearly we have P(S) ≤ σ(S) and P(S) ≥ S(S).
One interpretation of P(S) is that if this value is at least k then it follows that for any g1, g2, …, gk ∈ S×, there is some s ∈ S such that S = 〈gi, s 〉, for 1 ≤ i ≤ k. In this case, S is said to have spread at least k. (Note that the lower bound S(S) for P(S) can be computed from the list of primitive permutation characters of S.)
Moreover, P(S) ≥ k implies that the element s can be chosen uniformly from a fixed conjugacy class of S. This is called uniform spread at least k in [BGK08].
It is proved in [GK00] that all finite simple groups have uniform spread at least 1, that is, for any element x ∈ S×, there is an element y in a prescribed class of S such that G = 〈x, y 〉 holds. In [BGK08,Corollary 1.3], it is shown that all finite simple groups have uniform spread at least 2, and the finite simple groups with (uniform) spread exactly 2 are listed.
Concerning the spread, it should be mentioned that the methods used here and in [BGK08] are nonconstructive in the sense that they cannot be used for finding an element s that generates G together with each of the k prescribed elements g1, g2, …, gk.
Now consider g ∈ G \S. Since P( gk, s ) ≥ P( g, s ) for any positive integer k, we can assume that g has prime order p, say. We set H = 〈S, g 〉 ≤ G, with [H:S] = p, choose a transversal T of H in G, let M′(H,s): = M(H,s) \{ S }, and let M/ ∼ ′(H,s) denote a set of representatives of H-conjugacy classes of these groups. As above,

|{ h ∈ H; S ⊄ eq 〈sh, g 〉}| / |H|

=

|{ h ∈ H; 〈sh, g 〉 ≠ H }| / |H|

≤

| ∑ M ∈ M′(H,s) | |{ h ∈ H; h g h−1 ∈ M }| / |H|

=

| ∑ M ∈ M′(H,s) | 1MH(g) / 1MH(1)

=

| ∑ M ∈ M/ ∼ ′(H,s) | 1MH(g) ·1MH(s) / 1MH(1)

(Note that no summand for M = S occurs, so each group in M/ ∼ ′(H,s) is self-normalizing.) We abbreviate the right hand side by σ(H,g,s), and set σ′( H, s ) = max{ σ(H,g,s); g ∈ H \S, |g| = [H:S] }. Then we get P( g, s ) ≤ |T|−1 ·∑t ∈ T σ(Ht,gt,s) and thus

P( G, s ) ≤ | max | { P( S, s ), | max | { σ′( H, s ); S ≤ H ≤ G, [H:S] prime } } .

For convenience, we set P′(G,s) = max{ P(g,s); g ∈ G \S }.

### 2.2 Computational Criteria

The following criteria will be used when we have to show the existence or nonexistence of x1, x2, …, xk, and s ∈ G with the property 〈xi, s 〉 = G for 1 ≤ i ≤ k. Note that manipulating lists of integers (representing fixed or moved points) is much more efficient than testing whether certain permutations generate a given group.
Lemma 1 Let G be a finite group, s ∈ G×, and X = ∪M ∈ M(G,s) G/M. For x1, x2, …, xk ∈ G, the conjugate s′ of s satisfies 〈xi, s′ 〉 = G for 1 ≤ i ≤ k if and only if FixX(s′) ∩∪i=1k FixX(xi) = ∅ holds.
PROOF. If sg ∈ U ≤ G for some g ∈ G then FixX(U) = ∅ if and only if U = G holds; note that FixX(G) = ∅, and FixX(U) = ∅ implies that U ⊄ eq h−1 M h holds for all h ∈ G and M ∈ M(G,s), thus U = G.
Applied to U = 〈xi, s′ 〉, we get 〈xi, s′ 〉 = G if and only if FixX(s′) ∩FixX(xi) = FixX(U) = ∅. [¯]
Corollary 2 If M(G,s) = { M } in the situation of Lemma 2.1 then there is a conjugate s′ of s that satisfies 〈xi, s′ 〉 = G for 1 ≤ i ≤ k if and only if ∪i=1k FixX(xi) ≠ X.
Corollary 3 Let G be a finite simple group and let X be a G-set such that each g ∈ G fixes at least one point in X but that FixX(G) = ∅ holds. If x1, x2, …xk are elements in G such that ∪i=1k FixX(xi) = X holds then for each s ∈ G there is at least one i with 〈xi, s 〉 ≠ G.

## 3 GAP Functions for the Computations

After the introduction of general utilities in Section 3.1, we distinguish two different tasks. Section 3.2 introduces functions that will be used in the following to compute σ(g,s) with character-theoretic methods. Functions for computing P(g,s) or an upper bound for this value will be introduced in Section 3.3.
The GAP functions shown in Section 3 are collected in the file `tst/probgen.g` that is distributed with the GAP Character Table Library, see `http://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib`
The functions have been designed for the examples in the later sections, they could be generalized and optimized for other examples. It is not our aim to provide a package for this functionality.

### 3.1 General Utilities

Let `list` be a dense list and `prop` be a unary function that returns `true` or `false` when applied to the entries of `list`. `PositionsProperty` returns the set of positions in `list` for which `true` is returned.

        gap> if not IsBound( PositionsProperty ) then
        >      PositionsProperty:= function( list, prop )
        >        return Filtered( [ 1 .. Length( list ) ], i -> prop( list[i] ) );
        >      end;
        >    fi;

The following two functions implement loops over ordered triples (and quadruples, respectively) in a Cartesian product. A prescribed function `prop` is subsequently applied to the triples (quadruples), and if the result of this call is `true` then this triple (quadruple) is returned immediately; if none of the calls to `prop` yields `true` then `fail` is returned.

        gap> BindGlobal( "TripleWithProperty", function( threelists, prop )
        >     local i, j, k, test;
        >
        >     for i in threelists[1] do
        >       for j in threelists[2] do
        >         for k in threelists[3] do
        >           test:= [ i, j, k ];
        >           if prop( test ) then
        >               return test;
        >           fi;
        >         od;
        >       od;
        >     od;
        >
        >     return fail;
        > end );

        gap> BindGlobal( "QuadrupleWithProperty", function( fourlists, prop )
        >     local i, j, k, l, test;
        >
        >     for i in fourlists[1] do
        >       for j in fourlists[2] do
        >         for k in fourlists[3] do
        >           for l in fourlists[4] do
        >             test:= [ i, j, k, l ];
        >             if prop( test ) then
        >               return test;
        >             fi;
        >           od;
        >         od;
        >       od;
        >     od;
        >
        >     return fail;
        > end );

Of course one could do better by considering unordered n-tuples when several of the argument lists are equal, and in practice, backtrack searches would often allow one to prune parts of the search tree in early stages. However, the above loops are not time critical in the examples presented here, so the possible improvements are not worth the effort for our purposes.
The function `PrintFormattedArray` prints the matrix `array` in a columnwise formatted way. (The only diference to the GAP library function `PrintArray` is that `PrintFormattedArray` chooses each column width according to the entries only in this column not w.r.t. the whole matrix.)

        gap> BindGlobal( "PrintFormattedArray", function( array )
        >      local colwidths, n, row;
        >      array:= List( array, row -> List( row, String ) );
        >      colwidths:= List( TransposedMat( array ),
        >                        col -> Maximum( List( col, Length ) ) );
        >      n:= Length( array[1] );
        >      for row in List( array, row -> List( [ 1 .. n ],
        >                   i -> FormattedString( row[i], colwidths[i] ) ) ) do
        >        Print( "  ", JoinStringsWithSeparator( row, " " ), "\n" );
        >      od;
        > end );

Finally, `CleanWorkspace` is a utility for reducing the space needed. This is achieved by unbinding those user variables that are not write protected and are not mentioned in the list `NeededVariables` of variable names that are bound now, and by flushing the caches of tables of marks and character tables.

        gap> BindGlobal( "NeededVariables", NamesUserGVars() );
        gap> BindGlobal( "CleanWorkspace", function()
        >       local name, record;
        >
        >       for name in Difference( NamesUserGVars(), NeededVariables ) do
        >        if not IsReadOnlyGlobal( name ) then
        >          UnbindGlobal( name );
        >        fi;
        >      od;
        >      for record in [ LIBTOMKNOWN, LIBTABLE ] do
        >        for name in RecNames( record.LOADSTATUS ) do
        >          Unbind( record.LOADSTATUS.( name ) );
        >          Unbind( record.( name ) );
        >        od;
        >      od;
        > end );

The function `PossiblePermutationCharacters` takes two ordinary character tables `sub` and `tbl`, computes the possible class fusions from `sub` to `tbl`, then induces the trivial character of `sub` to `tbl`, w.r.t. these fusions, and returns the set of these class functions. (So if `sub` and `tbl` are the character tables of groups H and G, respectively, where H is a subgroup of G, then the result contains the permutation character 1HG.)
Note that the columns of the character tables in the GAP Character Table Library are not explicitly associated with particular conjugacy classes of the corresponding groups, so from the character tables, we can compute only possible class fusions, i.e., maps between the columns of two tables that satisfy certain necessary conditions, see the section about the function `PossibleClassFusions` in the GAP Reference Manual for details. There is no problem if the permutation character is uniquely determined by the character tables, in all other cases we give ad hoc arguments for resolving the ambiguities.

        gap> BindGlobal( "PossiblePermutationCharacters", function( sub, tbl )
        >     local fus, triv;
        >
        >     fus:= PossibleClassFusions( sub, tbl );
        >     if fus = fail then
        >       return fail;
        >     fi;
        >     triv:= [ TrivialCharacter( sub ) ];
        >
        >     return Set( List( fus, map -> Induced( sub, tbl, triv, map )[1] ) );
        > end );

### 3.2 Character-Theoretic Computations

We want to use the GAP libraries of character tables and of tables of marks, and proceed in three steps.
First we extract the primitive permutation characters from the library information if this is available; for that, we write the function `PrimitivePermutationCharacters`. Then the result can be used as the input for the function `ApproxP`, which computes the values σ( g, s ). Finally, the functions `ProbGenInfoSimple` and `ProbGenInfoAlmostSimple` compute S( G ).
For a group G whose character table T is contained in the GAP character table library, the complete set of primitive permutation characters can be easily computed if the character tables of all maximal subgroups and their class fusions into T are known (in this case, we check whether the attribute `Maxes` of T is bound) or if the table of marks of G and the class fusion from T into this table of marks are known (in this case, we check whether the attribute `FusionToTom` of T is bound). If the attribute `UnderlyingGroup` of T is bound then this group can be used to compute the primitive permutation characters. The latter happens if T was computed from the group object in GAP; for tables in the GAP character table library, this is not the case by default.
The GAP function `PrimitivePermutationCharacters` tries to compute the primitive permutation characters of a group using this information; it returns the required list of characters if this can be computed this way, otherwise `fail` is returned. (For convenience, we use the GAP mechanism of attributes in order to store the permutation characters in the character table object once they have been computed.)

        gap> DeclareAttribute( "PrimitivePermutationCharacters", IsCharacterTable );
        gap> InstallMethod( PrimitivePermutationCharacters,
        >     [ IsCharacterTable ],
        >     function( tbl )
        >     local maxes, tom, G;
        >
        >     if HasMaxes( tbl ) then
        >       maxes:= List( Maxes( tbl ), CharacterTable );
        >       if ForAll( maxes, s -> GetFusionMap( s, tbl ) <> fail ) then
        >         return List( maxes, subtbl -> TrivialCharacter( subtbl )^tbl );
        >       fi;
        >     elif HasFusionToTom( tbl ) then
        >       tom:= TableOfMarks( tbl );
        >       maxes:= MaximalSubgroupsTom( tom );
        >       return PermCharsTom( tbl, tom ){ maxes[1] };
        >     elif HasUnderlyingGroup( tbl ) then
        >       G:= UnderlyingGroup( tbl );
        >       return List( MaximalSubgroupClassReps( G ),
        >                    M -> TrivialCharacter( M )^tbl );
        >     fi;
        >
        >     return fail;
        > end );

The function `ApproxP` takes a list `primitives` of primitive permutation characters of a group G, say, and the position `spos` of the class sG in the character table of G.
Assume that the elements in `primitives` have the form 1MG, for suitable maximal subgroups M of G, and let M/ ∼ be the set of these groups M. `ApproxP` returns the class function ψ of G that is defined by ψ(1) = 0 and

ψ(g) =

∑
M ∈ M/ ∼

1MG(s) ·1MG(g)

1MG(1)

otherwise.
If `primitives` contains all those primitive permutation characters 1MG of G (with multiplicity according to the number of conjugacy classes of these maximal subgroups) that do not vanish at s, and if all these M are self-normalizing in G -this holds for example if G is a finite simple group- then ψ(g) = σ( g, s ) holds.

        gap> BindGlobal( "ApproxP", function( primitives, spos )
        >     local sum;
        >
        >     sum:= ShallowCopy( Sum( List( primitives,
        >                                   pi -> pi[ spos ] * pi / pi[1] ) ) );
        >     sum[1]:= 0;
        >
        >     return sum;
        > end );

Note that for computations with permutation characters, it would make the functions more complicated (and not more efficient) if we would consider only elements g of prime order, and only one representative of Galois conjugate classes.
The next functions needed in this context compute σ(S) and S( S ), for a simple group S, and σ′(G,s) for an almost simple group G with socle S, respectively.
`ProbGenInfoSimple` takes the character table `tbl` of S as its argument. If the full list of primitive permutation characters of S cannot be computed with `PrimitivePermutationCharacters` then the function returns `fail`. Otherwise `ProbGenInfoSimple` returns a list containing the identifier of the table, the value σ(S), the integer S( S ), a list of ATLAS names of representatives of Galois families of those classes of elements s for which σ(S) = σ( S, s ) holds, and the list of the corresponding cardinalities |M(S,s)|.

        gap> BindGlobal( "ProbGenInfoSimple", function( tbl )
        >     local prim, max, min, bound, s;
        >     prim:= PrimitivePermutationCharacters( tbl );
        >     if prim = fail then
        >       return fail;
        >     fi;
        >     max:= List( [ 1 .. NrConjugacyClasses( tbl ) ],
        >                 i -> Maximum( ApproxP( prim, i ) ) );
        >     min:= Minimum( max );
        >     bound:= Inverse( min );
        >     if IsInt( bound ) then
        >       bound:= bound - 1;
        >     else
        >       bound:= Int( bound );
        >     fi;
        >     s:= PositionsProperty( max, x -> x = min );
        >     s:= List( Set( List( s, i -> ClassOrbit( tbl, i ) ) ), i -> i[1] );
        >     return [ Identifier( tbl ),
        >              min,
        >              bound,
        >              AtlasClassNames( tbl ){ s },
        >              Sum( List( prim, pi -> pi{ s } ) ) ];
        > end );

`ProbGenInfoAlmostSimple` takes the character tables `tblS` and `tblG` of S and G, and a list `sposS` of class positions (w.r.t. `tblS`) as its arguments. It is assumed that S is simple and has prime index in G. If `PrimitivePermutationCharacters` can compute the full list of primitive permutation characters of G then the function returns a list containing the identifier of `tblG`, the maximum m of σ′( G, s ), for s in the classes described by `sposS`, a list of ATLAS names (in G) of the classes of elements s for which this maximum is attained, and the list of the corresponding cardinalities |M′(G,s)|. When `PrimitivePermutationCharacters` returns `fail`, also `ProbGenInfoAlmostSimple` returns `fail`.

        gap> BindGlobal( "ProbGenInfoAlmostSimple", function( tblS, tblG, sposS )
        >     local p, fus, inv, prim, sposG, outer, approx, l, max, min,
        >           s, cards, i, names;
        >
        >     p:= Size( tblG ) / Size( tblS );
        >     if not IsPrimeInt( p )
        >        or Length( ClassPositionsOfNormalSubgroups( tblG ) ) <> 3 then
        >       return fail;
        >     fi;
        >     fus:= GetFusionMap( tblS, tblG );
        >     if fus = fail then
        >       return fail;
        >     fi;
        >     inv:= InverseMap( fus );
        >     prim:= PrimitivePermutationCharacters( tblG );
        >     if prim = fail then
        >       return fail;
        >     fi;
        >     sposG:= Set( fus{ sposS } );
        >     outer:= Difference( PositionsProperty(
        >                 OrdersClassRepresentatives( tblG ), IsPrimeInt ), fus );
        >     approx:= List( sposG, i -> ApproxP( prim, i ){ outer } );
        >     if IsEmpty( outer ) then
        >       max:= List( approx, x -> 0 );
        >     else
        >       max:= List( approx, Maximum );
        >     fi;
        >     min:= Minimum( max);
        >     s:= sposG{ PositionsProperty( max, x -> x = min ) };
        >     cards:= List( prim, pi -> pi{ s } );
        >     for i in [ 1 .. Length( prim ) ] do
        >       # Omit the character that is induced from the simple group.
        >       if ForAll( prim[i], x -> x = 0 or x = prim[i][1] ) then
        >         cards[i]:= 0;
        >       fi;
        >     od;
        >     names:= AtlasClassNames( tblG ){ s };
        >     Perform( names, ConvertToStringRep );
        >
        >     return [ Identifier( tblG ),
        >              min,
        >              names,
        >              Sum( cards ) ];
        > end );

The next function computes σ(G,s) from the character table `tbl` of a simple or almost simple group G, the name `sname` of the class of s in this table, the list `maxes` of the character tables of all subgroups M with M ∈ M(G,s), and the list `numpermchars` of the numbers of possible permutation characters induced from `maxes`. If the string `"outer"` is given as an optional argument then G is assumed to be an automorphic extension of a simple group S, with [G:S] a prime, and σ′(G,s) is returned. In both situations, the result is `fail` if the numbers of possible permutation characters induced from `maxes` do not coincide with the numbers prescribed in `numpermchars`.

        gap> BindGlobal( "SigmaFromMaxes", function( arg )
        >     local t, sname, maxes, numpermchars, prim, spos, outer;
        >
        >     t:= arg[1];
        >     sname:= arg[2];
        >     maxes:= arg[3];
        >     numpermchars:= arg[4];
        >     prim:= List( maxes, s -> PossiblePermutationCharacters( s, t ) );
        >     spos:= Position( AtlasClassNames( t ), sname );
        >     if ForAny( [ 1 .. Length( maxes ) ],
        >                i -> Length( prim[i] ) <> numpermchars[i] ) then
        >       return fail;
        >     elif Length( arg ) = 5 and arg[5] = "outer" then
        >       outer:= Difference(
        >           PositionsProperty( OrdersClassRepresentatives( t ), IsPrimeInt ),
        >           ClassPositionsOfDerivedSubgroup( t ) );
        >       return Maximum( ApproxP( Concatenation( prim ), spos ){ outer } );
        >     else
        >       return Maximum( ApproxP( Concatenation( prim ), spos ) );
        >     fi;
        > end );

The following function allows us to extract information about M(G,s) from the character table `tbl` of G and a list `snames` of class positions of s. If `Maxes( tbl )` is stored then the names of the character tables of the subgroups in M(G,s) and the number of conjugates are printed, otherwise `fail` is printed.

        gap> BindGlobal( "DisplayProbGenMaxesInfo", function( tbl, snames )
        >     local mx, prim, i, spos, nonz, indent, j;
        >
        >     if not HasMaxes( tbl ) then
        >       Print( Identifier( tbl ), ": fail\n" );
        >       return;
        >     fi;
        >
        >     mx:= List( Maxes( tbl ), CharacterTable );
        >     prim:= List( mx, s -> TrivialCharacter( s )^tbl );
        >     Assert( 1, SortedList( prim ) =
        >                SortedList( PrimitivePermutationCharacters( tbl ) ) );
        >     for i in [ 1 .. Length( prim ) ] do
        >       # Deal with the case that the subgroup is normal.
        >       if ForAll( prim[i], x -> x = 0 or x = prim[i][1] ) then
        >         prim[i]:= prim[i] / prim[i][1];
        >       fi;
        >     od;
        >
        >     spos:= List( snames,
        >                  nam -> Position( AtlasClassNames( tbl ), nam ) );
        >     nonz:= List( spos, x -> PositionsProperty( prim, pi -> pi[x] <> 0 ) );
        >     for i in [ 1 .. Length( spos ) ] do
        >       Print( Identifier( tbl ), ", ", snames[i], ": " );
        >       indent:= ListWithIdenticalEntries(
        >           Length( Identifier( tbl ) ) + Length( snames[i] ) + 4, ' ' );
        >       if not IsEmpty( nonz[i] ) then
        >         Print( Identifier( mx[ nonz[i][1] ] ), "  (",
        >                prim[ nonz[i][1] ][ spos[i] ], ")\n" );
        >         for j in [ 2 .. Length( nonz[i] ) ] do
        >           Print( indent, Identifier( mx[ nonz[i][j] ] ), "  (",
        >                prim[ nonz[i][j] ][ spos[i] ], ")\n" );
        >         od;
        >       else
        >         Print( "\n" );
        >       fi;
        >     od;
        > end );

### 3.3 Computations with Groups

Here, the task is to compute P(g,s) or P(G,s) using explicit computations with G, where the character-theoretic bounds are not sufficient.
We start with small utilities that make the examples shorter.
For a finite solvable group `G`, the function `PcConjugacyClassReps` returns a list of representatives of the conjugacy classes of `G`, which are computed using a polycyclic presentation for `G`.

        gap> BindGlobal( "PcConjugacyClassReps", function( G )
        >      local iso;
        >
        >      iso:= IsomorphismPcGroup( G );
        >      return List( ConjugacyClasses( Image( iso ) ),
        >               c -> PreImagesRepresentative( iso, Representative( c ) ) );
        > end );

For a finite group `G`, a list `primes` of prime integers, and a normal subgroup `N` of `G`, the function `ClassesOfPrimeOrder` returns a list of those conjugacy classes of `G` that are not contained in `N` and whose elements' orders occur in `primes`.
For each prime p in `primes`, first class representatives of order p in a Sylow p subgroup of `G` are computed, then the representatives in `N` are discarded, and then representatives w. r. t. conjugacy in `G` are computed.
(Note that this approach may be inappropriate for example if a large elementary abelian Sylow p subgroup occurs, and if the conjugacy tests in `G` are expensive, see Section 5.14.)

        gap> BindGlobal( "ClassesOfPrimeOrder", function( G, primes, N )
        >      local ccl, p, syl, reps;
        >
        >      ccl:= [];
        >      for p in primes do
        >        syl:= SylowSubgroup( G, p );
        >        reps:= Filtered( PcConjugacyClassReps( syl ),
        >                   r -> Order( r ) = p and not r in N );
        >        Append( ccl, DuplicateFreeList( List( reps,
        >                                          r -> ConjugacyClass( G, r ) ) ) );
        >      od;
        >
        >      return ccl;
        > end );

The function `IsGeneratorsOfTransPermGroup` takes a transitive permutation group `G` and a list `list` of elements in `G`, and returns `true` if the elements in `list` generate `G`, and `false` otherwise. The main point is that the return value `true` requires the group generated by `list` to be transitive, and the check for transitivity is much cheaper than the test whether this group is equal to `G`.

        gap> BindGlobal( "IsGeneratorsOfTransPermGroup", function( G, list )
        >     local S;
        >
        >     if not IsTransitive( G ) then
        >       Error( "<G> must be transitive on its moved points" );
        >     fi;
        >     S:= SubgroupNC( G, list );
        >
        >     return IsTransitive( S, MovedPoints( G ) ) and Size( S ) = Size( G );
        > end );

`RatioOfNongenerationTransPermGroup` takes a transitive permutation group `G` and two elements `g` and `s` of `G`, and returns the proportion P(g,s). (The function tests the (non)generation only for representatives of CG(g)-CG(s)-double cosets. Note that for c1 ∈ CG(g), c2 ∈ CG(s), and a representative r ∈ G, we have 〈gc1 r c2, s 〉 = 〈gr, s 〉c2.)

        gap> BindGlobal( "RatioOfNongenerationTransPermGroup", function( G, g, s )
        >     local nongen, pair;
        >
        >     if not IsTransitive( G ) then
        >       Error( "<G> must be transitive on its moved points" );
        >     fi;
        >     nongen:= 0;
        >     for pair in DoubleCosetRepsAndSizes( G, Centralizer( G, g ),
        >                     Centralizer( G, s ) ) do
        >       if not IsGeneratorsOfTransPermGroup( G, [ s, g^pair[1] ] ) then
        >         nongen:= nongen + pair[2];
        >       fi;
        >     od;
        >
        >     return nongen / Size( G );
        > end );

Let G be a group, and let `groups` be a list [ G1, G2, …, Gn ] of permutation groups such that Gi describes the action of G on a set Ωi, say. Moreover, we require that for 1 ≤ i, j ≤ n, mapping the `GeneratorsOfGroup` list of Gi to that of Gj defines an isomorphism. `DiagonalProductOfPermGroups` takes `groups` as its argument, and returns the action of G on the disjoint union of Ω1, Ω2, …, Ωn.

        gap> BindGlobal( "DiagonalProductOfPermGroups", function( groups )
        >     local prodgens, deg, i, gens, D, pi;
        >
        >     prodgens:= GeneratorsOfGroup( groups[1] );
        >     deg:= NrMovedPoints( prodgens );
        >     for i in [ 2 .. Length( groups ) ] do
        >       gens:= GeneratorsOfGroup( groups[i] );
        >       D:= MovedPoints( gens );
        >       pi:= MappingPermListList( D, [ deg+1 .. deg+Length( D ) ] );
        >       deg:= deg + Length( D );
        >       prodgens:= List( [ 1 .. Length( prodgens ) ],
        >                        i -> prodgens[i] * gens[i]^pi );
        >     od;
        >
        >     return Group( prodgens );
        > end );

The following two functions are used to reduce checks of generation to class representatives of maximal order. Note that if 〈s, g 〉 is a proper subgroup of G then also 〈sk, g 〉 is a proper subgroup of G, so we need not check powers sk different from s in this situation.
For an ordinary character table `tbl`, the function `RepresentativesMaximallyCyclicSubgroups` returns a list of class positions, containing one class of generators for each class of maximally cyclic subgroups.

        gap> BindGlobal( "RepresentativesMaximallyCyclicSubgroups", function( tbl )
        >     local n, result, orders, p, pmap, i, j;
        >
        >     # Initialize.
        >     n:= NrConjugacyClasses( tbl );
        >     result:= BlistList( [ 1 .. n ], [ 1 .. n ] );
        >
        >     # Omit powers of smaller order.
        >     orders:= OrdersClassRepresentatives( tbl );
        >     for p in Set( Factors( Size( tbl ) ) ) do
        >       pmap:= PowerMap( tbl, p );
        >       for i in [ 1 .. n ] do
        >         if orders[ pmap[i] ] < orders[i] then
        >           result[ pmap[i] ]:= false;
        >         fi;
        >       od;
        >     od;
        >
        >     # Omit Galois conjugates.
        >     for i in [ 1 .. n ] do
        >       if result[i] then
        >         for j in ClassOrbit( tbl, i ) do
        >           if i <> j then
        >             result[j]:= false;
        >           fi;
        >         od;
        >       fi;
        >     od;
        >
        >     # Return the result.
        >     return ListBlist( [ 1 .. n ], result );
        > end );

Let `G` be a finite group, `tbl` be the ordinary character table of `G`, and `cols` be a list of class positions in `tbl`, for example the list returned by `RepresentativesMaximallyCyclicSubgroups`. The function `ClassesPerhapsCorrespondingToTableColumns` returns the sublist of those conjugacy classes of `G` for which the corresponding column in `tbl` can be contained in `cols`, according to element order and class size.

        gap> BindGlobal( "ClassesPerhapsCorrespondingToTableColumns",
        >    function( G, tbl, cols )
        >     local orders, classes, invariants;
        >
        >     orders:= OrdersClassRepresentatives( tbl );
        >     classes:= SizesConjugacyClasses( tbl );
        >     invariants:= List( cols, i -> [ orders[i], classes[i] ] );
        >
        >     return Filtered( ConjugacyClasses( G ),
        >         c -> [ Order( Representative( c ) ), Size(c) ] in invariants );
        > end );

The next function computes, for a finite group G and subgroups M1, M2, …, Mn of G, an upper bound for max{ ∑i=1n μ(g,G/Mi); g ∈ G \Z(G) }. So if the Mi are the groups in M(G,s), for some s ∈ G×, then we get an upper bound for σ(G,s).
The idea is that for M ≤ G and g ∈ G of order p, we have

μ(g,G/M) = |gG ∩M| / |gG| ≤ | ∑ h ∈ C | |hM| / |gG| = | ∑ h ∈ C | |hM| ·|CG(g)| / |G| ,

where C is a set of class representatives h ∈ M of all those classes that satisfy |h| = p and |CG(h)| = |CG(g)|, and in the case that G is a permutation group additionally that h and g move the same number of points. (Note that it is enough to consider elements of prime order.)
For computing the maximum of the rightmost term in this inequality, for g ∈ G \Z(G), we need not determine the G-conjugacy of class representatives in M. Of course we pay the price that the result may be larger than the leftmost term. However, if the maximal sum is in fact taken only over a single class representative, we are sure that equality holds. Thus we return a list of length two, containing the maximum of the right hand side of the above inequality and a Boolean value indicating whether this is equal to max{ μ(g,G/M); g ∈ G \Z(G) } or just an upper bound.
The arguments for `UpperBoundFixedPointRatios` are the group `G`, a list `maxesclasses` such that the i-th entry is a list of conjugacy classes of Mi, which covers all classes of prime element order in Mi, and either `true` or `false`, where `true` means that the exact value of σ(G,s) is computed, not just an upper bound; this can be much more expensive because of the conjugacy tests in G that may be necessary. (We try to reduce the number of conjugacy tests in this case, the second half of the code is not completely straightforward. The special treatment of conjugacy checks for elements with the same sets of fixed points is essential in the computation of σ′(G,s) for G = PGL(6,4); the critical input line is `ApproxPForOuterClassesInGL( 6, 4 )`, see Section 5.7. Currently the standard GAP conjugacy test for an element of order three and its inverse in G \G′ requires hours of CPU time, whereas the check for existence of a conjugating element in the stabilizer of the common set of fixed points of the two elements is almost free of charge.)
`UpperBoundFixedPointRatios` can be used to compute σ′(G,s) in the case that G is an automorphic extension of a simple group S, with [G:S] = p a prime; if M′(G,s) = { M1, M2, …, Mn } then the i-th entry of `maxesclasses` must contain only the classes of element order p in Mi \(Mi ∩S).

        gap> BindGlobal( "UpperBoundFixedPointRatios",
        >    function( G, maxesclasses, truetest )
        >     local myIsConjugate, invs, info, c, r, o, inv, pos, sums, max, maxpos,
        >           maxlen, reps, split, i, found, j;
        >
        >     myIsConjugate:= function( G, x, y )
        >       local movx, movy;
        >
        >       movx:= MovedPoints( x );
        >       movy:= MovedPoints( y );
        >       if movx = movy then
        >         G:= Stabilizer( G, movx, OnSets );
        >       fi;
        >       return IsConjugate( G, x, y );
        >     end;
        >
        >     invs:= [];
        >     info:= [];
        >
        >     # First distribute the classes according to invariants.
        >     for c in Concatenation( maxesclasses ) do
        >       r:= Representative( c );
        >       o:= Order( r );
        >       # Take only prime order representatives.
        >       if IsPrimeInt( o ) then
        >         inv:= [ o, Size( Centralizer( G, r ) ) ];
        >         # Omit classes that are central in `G'.
        >         if inv[2] <> Size( G ) then
        >           if IsPerm( r ) then
        >             Add( inv, NrMovedPoints( r ) );
        >           fi;
        >           pos:= First( [ 1 .. Length( invs ) ], i -> inv = invs[i] );
        >           if pos = fail then
        >             # This class is not `G'-conjugate to any of the previous ones.
        >             Add( invs, inv );
        >             Add( info, [ [ r, Size( c ) * inv[2] ] ] );
        >           else
        >             # This class may be conjugate to an earlier one.
        >             Add( info[ pos ], [ r, Size( c ) * inv[2] ] );
        >           fi;
        >         fi;
        >       fi;
        >     od;
        >
        >     if info = [] then
        >       return [ 0, true ];
        >     fi;
        >
        >     repeat
        >       # Compute the contributions of the classes with the same invariants.
        >       sums:= List( info, x -> Sum( List( x, y -> y[2] ) ) );
        >       max:= Maximum( sums );
        >       maxpos:= Filtered( [ 1 .. Length( info ) ], i -> sums[i] = max );
        >       maxlen:= List( maxpos, i -> Length( info[i] ) );
        >
        >       # Split the sets with the same invariants if necessary
        >       # and if we want to compute the exact value.
        >       if truetest and not 1 in maxlen then
        >         # Make one conjugacy test.
        >         pos:= Position( maxlen, Minimum( maxlen ) );
        >         reps:= info[ maxpos[ pos ] ];
        >         if myIsConjugate( G, reps[1][1], reps[2][1] ) then
        >           # Fuse the two classes.
        >           reps[1][2]:= reps[1][2] + reps[2][2];
        >           reps[2]:= reps[ Length( reps ) ];
        >           Unbind( reps[ Length( reps ) ] );
        >         else
        >           # Split the list. This may require additional conjugacy tests.
        >           Unbind( info[ maxpos[ pos ] ] );
        >           split:= [ reps[1], reps[2] ];
        >           for i in [ 3 .. Length( reps ) ] do
        >             found:= false;
        >             for j in split do
        >               if myIsConjugate( G, reps[i][1], j[1] ) then
        >                 j[2]:= reps[i][2] + j[2];
        >                 found:= true;
        >                 break;
        >               fi;
        >             od;
        >             if not found then
        >               Add( split, reps[i] );
        >             fi;
        >           od;
        >
        >           info:= Compacted( Concatenation( info,
        >                                            List( split, x -> [ x ] ) ) );
        >         fi;
        >       fi;
        >     until 1 in maxlen or not truetest;
        >
        >     return [ max / Size( G ), 1 in maxlen ];
        > end );

Suppose that C1, C2, C3 are conjugacy classes in G, and that we have to prove, for each (x1, x2, x3) ∈ C1 ×C2 ×C3, the existence of an element s in a prescribed class C of G such that 〈x1, s 〉 = 〈x2, s 〉 = 〈x2, s 〉 = G holds.
We have to check only representatives under the conjugation action of G on C1 ×C2 ×C3. For each representative, we try a prescribed number of random elements in C. If this is successful then we are done. The following two functions implement this idea.
For a group G and a list [ g1, g2, …, gn ] of elements in G, `OrbitRepresentativesProductOfClasses` returns a list R(G, g1, g2, …, gn) of representatives of G-orbits on the Cartesian product g1G ×g2G ×…×gnG.
The idea behind this function is to choose R(G, g1) = { ( g1 ) } in the case n = 1, and, for n > 1,

R(G, g1, g2, …, gn)

=

{ (h1, h2, …, hn) | (h1, h2, …, hn−1) ∈ R(G, g1, g2, …, gn−1),

hn = gnd, for d ∈ D } ,

where D is a set of representatives of double cosets CG(gn) \G / ∩i=1n−1 CG(hi).

        gap> BindGlobal( "OrbitRepresentativesProductOfClasses",
        >    function( G, classreps )
        >     local cents, n, orbreps;
        >
        >     cents:= List( classreps, x -> Centralizer( G, x ) );
        >     n:= Length( classreps );
        >
        >     orbreps:= function( reps, intersect, pos )
        >       if pos > n then
        >         return [ reps ];
        >       fi;
        >       return Concatenation( List(
        >           DoubleCosetRepsAndSizes( G, cents[ pos ], intersect ),
        >             r -> orbreps( Concatenation( reps, [ classreps[ pos ]^r[1] ] ),
        >                  Intersection( intersect, cents[ pos ]^r[1] ), pos+1 ) ) );
        >     end;
        >
        >     return orbreps( [ classreps[1] ], cents[1], 2 );
        > end );

The function `RandomCheckUniformSpread` takes a transitive permutation group G, a list of class representatives gi ∈ G, an element s ∈ G, and a positive integer N. The return value is `true` if for each representative of G-orbits on the product of the classes giG, a good conjugate of s is found in at most N random tests.

        gap> BindGlobal( "RandomCheckUniformSpread", function( G, classreps, s, try )
        >     local elms, found, i, conj;
        >
        >     if not IsTransitive( G, MovedPoints( G ) ) then
        >       Error( "<G> must be transitive on its moved points" );
        >     fi;
        >
        >     # Compute orbit representatives of G on the direct product,
        >     # and try to find a good conjugate of s for each representative.
        >     for elms in OrbitRepresentativesProductOfClasses( G, classreps ) do
        >       found:= false;
        >       for i in [ 1 .. try ] do
        >         conj:= s^Random( G );
        >         if ForAll( elms,
        >               x -> IsGeneratorsOfTransPermGroup( G, [ x, conj ] ) ) then
        >           found:= true;
        >           break;
        >         fi;
        >       od;
        >       if not found then
        >         return elms;
        >       fi;
        >     od;
        >
        >     return true;
        > end );

Of course this approach is not suitable for disproving the existence of s, but it is much cheaper than an exhaustive search in the class C. (Typically, |C| is large whereas the |Ci| are small.)
The following function can be used to verify that a given n-tuple (x1, x2, …, xn) of elements in a group G has the property that for all elements g ∈ G, at least one xi satisfies 〈xi, g 〉. The arguments are a transitive permutation group G, a list of class representatives in G, and the n-tuple in question. The return value is a conjugate g of the given representatives that has the property if such an element exists, and `fail` otherwise.

        gap> BindGlobal( "CommonGeneratorWithGivenElements",
        >    function( G, classreps, tuple )
        >     local inter, rep, repcen, pair;
        >
        >     if not IsTransitive( G, MovedPoints( G ) ) then
        >       Error( "<G> must be transitive on its moved points" );
        >     fi;
        >
        >     inter:= Intersection( List( tuple, x -> Centralizer( G, x ) ) );
        >     for rep in classreps do
        >       repcen:= Centralizer( G, rep );
        >       for pair in DoubleCosetRepsAndSizes( G, repcen, inter ) do
        >         if ForAll( tuple,
        >            x -> IsGeneratorsOfTransPermGroup( G, [ x, rep^pair[1] ] ) ) then
        >           return rep;
        >         fi;
        >       od;
        >     od;
        >
        >     return fail;
        > end );

## 4 Character-Theoretic Computations

In this section, we apply the functions introduced in Section 3.2 to the character tables of simple groups that are available in the GAP Character Table Library.
Our first examples are the sporadic simple groups, in Section 4.1, then their automorphism groups are considered in Section 4.2.
Then we consider those other simple groups for which GAP provides enough information for automatically computing an upper bound on σ(G,s) -see Section 4.3- and their automorphic extensions -see Section 4.4.
After that, individual groups are considered.

### 4.1 Sporadic Simple Groups

The GAP Character Table Library contains the tables of maximal subgroups of all sporadic simple groups except B and M, so all primitive permutation characters can be computed via the function `PrimitivePermutationCharacters` for 24 of the 26 sporadic simple groups.

        gap> sporinfo:= [];;
        gap> spornames:= AllCharacterTableNames( IsSporadicSimple, true,
        >                                        IsDuplicateTable, false );;
        gap> for tbl in List( spornames, CharacterTable ) do
        >      info:= ProbGenInfoSimple( tbl );
        >      if info <> fail then
        >        Add( sporinfo, info );
        >      fi;
        >    od;

We show the result as a formatted table.

        gap> PrintFormattedArray( sporinfo );
           Co1    421/1545600         3671        [ "35A" ]    [ 4 ]
           Co2          1/270          269        [ "23A" ]    [ 1 ]
           Co3        64/6325           98        [ "21A" ]    [ 4 ]
           F3+ 1/269631216855 269631216854        [ "29A" ]    [ 1 ]
          Fi22         43/585           13        [ "16A" ]    [ 7 ]
          Fi23   2651/2416635          911        [ "23A" ]    [ 2 ]
            HN        4/34375         8593        [ "19A" ]    [ 1 ]
            HS        64/1155           18        [ "15A" ]    [ 2 ]
            He          3/595          198        [ "14C" ]    [ 3 ]
            J1           1/77           76        [ "19A" ]    [ 1 ]
            J2           5/28            5        [ "10C" ]    [ 3 ]
            J3          2/153           76        [ "19A" ]    [ 2 ]
            J4   1/1647124116   1647124115        [ "29A" ]    [ 1 ]
            Ly     1/35049375     35049374        [ "37A" ]    [ 1 ]
           M11            1/3            2        [ "11A" ]    [ 1 ]
           M12            1/3            2        [ "10A" ]    [ 3 ]
           M22           1/21           20        [ "11A" ]    [ 1 ]
           M23         1/8064         8063        [ "23A" ]    [ 1 ]
           M24       108/1265           11        [ "21A" ]    [ 2 ]
           McL      317/22275           70 [ "15A", "30A" ] [ 3, 3 ]
            ON       10/30723         3072        [ "31A" ]    [ 2 ]
            Ru         1/2880         2879        [ "29A" ]    [ 1 ]
           Suz       141/5720           40        [ "14A" ]    [ 3 ]
            Th       2/267995       133997 [ "27A", "27B" ] [ 2, 2 ]

We see that in all these cases, σ(G) < 1/2 and thus P( G ) ≥ 2, and all sporadic simple groups G except G = M11 and G = M12 satisfy σ(G) < 1/3. See 5.9 and 5.10 for a proof that also these two groups have uniform spread at least three.
The structures and multiplicities of the maximal subgroups containing s are as follows.

        gap> for entry in sporinfo do
        >      DisplayProbGenMaxesInfo( CharacterTable( entry[1] ), entry[4] );
        > od;
        Co1, 35A: (A5xJ2):2  (1)
                  (A6xU3(3)):2  (2)
                  (A7xL2(7)):2  (1)
        Co2, 23A: M23  (1)
        Co3, 21A: U3(5).3.2  (2)
                  L3(4).D12  (1)
                  s3xpsl(2,8).3  (1)
        F3+, 29A: 29:14  (1)
        Fi22, 16A: 2^10:m22  (1)
                   (2x2^(1+8)):U4(2):2  (1)
                   2F4(2)'  (4)
                   2^(5+8):(S3xA6)  (1)
        Fi23, 23A: 2..11.m23  (1)
                   L2(23)  (1)
        HN, 19A: U3(8).3_1  (1)
        HS, 15A: A8.2  (1)
                 5:4xa5  (1)
        He, 14C: 2^1+6.psl(3,2)  (1)
                 7^2:2psl(2,7)  (1)
                 7^(1+2):(S3x3)  (1)
        J1, 19A: 19:6  (1)
        J2, 10C: 2^1+4b:a5  (1)
                 a5xd10  (1)
                 5^2:D12  (1)
        J3, 19A: L2(19)  (1)
                 J3M3  (1)
        J4, 29A: frob  (1)
        Ly, 37A: 37:18  (1)
        M11, 11A: L2(11)  (1)
        M12, 10A: A6.2^2  (1)
                  M12M4  (1)
                  2xS5  (1)
        M22, 11A: L2(11)  (1)
        M23, 23A: 23:11  (1)
        M24, 21A: L3(4).3.2_2  (1)
                  2^6:(psl(3,2)xs3)  (1)
        McL, 15A: 3^(1+4):2S5  (1)
                  2.A8  (1)
                  5^(1+2):3:8  (1)
        McL, 30A: 3^(1+4):2S5  (1)
                  2.A8  (1)
                  5^(1+2):3:8  (1)
        ON, 31A: L2(31)  (1)
                 ONM8  (1)
        Ru, 29A: L2(29)  (1)
        Suz, 14A: J2.2  (2)
                  (a4xpsl(3,4)):2  (1)
        Th, 27A: ThN3B  (1)
                 ThM7  (1)
        Th, 27B: ThN3B  (1)
                 ThM7  (1)

For the remaining two sporadic simple groups, B and M, we choose suitable elements s. If G = B and s ∈ G is of order 47 then, by [Wil99], M(G,s) = { 47:23 }.

        gap> SigmaFromMaxes( CharacterTable( "B" ), "47A",
        >        [ CharacterTable( "47:23" ) ], [ 1 ] );
        1/174702778623598780219392000000

If G = M and s ∈ G is of order 59 then, by [HW04], M(G,s) = { L2(59) }. In this case, the permutation character is not uniquely determined by the character tables, but all possibilities lead to the same value for σ(G).

        gap> t:= CharacterTable( "M" );;
        gap> s:= CharacterTable( "L2(59)" );;
        gap> pi:= PossiblePermutationCharacters( s, t );;
        gap> Length( pi );
        5
        gap> spos:= Position( OrdersClassRepresentatives( t ), 59 );
        152
        gap> Set( List( pi, x -> Maximum( ApproxP( [ x ], spos ) ) ) );
        [ 1/3385007637938037777290625 ]

Essentially the same approach is taken in [GM01]. However, there s is restricted to classes of prime order. Thus the results in the above table are better for J2, HS, M24, McL, He, Suz, Co3, Fi22, Ly, Th, Co1, and J4. Besides that, the value 10 999 claimed in [GM01] for S( HN ) is not correct.

### 4.2 Automorphism Groups of Sporadic Simple Groups

Next we consider the automorphism groups of the sporadic simple groups. There are exactly 12 cases where nontrivial outer automorphisms exist, and then the simple group S has index 2 in its automorphism group G.

        gap> sporautnames:= AllCharacterTableNames( IsSporadicSimple, true,
        >                       IsDuplicateTable, false,
        >                       OfThose, AutomorphismGroup );;
        gap> sporautnames:= Difference( sporautnames, spornames );
        [ "F3+.2", "Fi22.2", "HN.2", "HS.2", "He.2", "J2.2", "J3.2", "M12.2",
          "M22.2", "McL.2", "ON.2", "Suz.2" ]

First we compute the values σ′(G,s), for the same s ∈ S that were chosen for the simple group S in Section 4.1.
For six of the groups G in question, the character tables of all maximal subgroups are available in the GAP Character Table Library. In these cases, the values σ′( G, s ) can be computed using `ProbGenInfoAlmostSimple`.
(The above statement can meanwhile be replaced by the statement that the character tables of all maximal subgroups are available for all twelve groups. We show the table results for all these groups but keep the individual computations from the original computations.)

        gap> sporautinfo:= [];;
        gap> fails:= [];;
        gap> for name in sporautnames do
        >      tbl:= CharacterTable( name{ [ 1 .. Position( name, '.' ) - 1 ] } );
        >      tblG:= CharacterTable( name );
        >      info:= ProbGenInfoSimple( tbl );
        >      info:= ProbGenInfoAlmostSimple( tbl, tblG,
        >          List( info[4], x -> Position( AtlasClassNames( tbl ), x ) ) );
        >      if info = fail then
        >        Add( fails, name );
        >      else
        >        Add( sporautinfo, info );
        >      fi;
        >    od;
        gap> PrintFormattedArray( sporautinfo );
           F3+.2         0         [ "29AB" ]    [ 1 ]
          Fi22.2  251/3861         [ "16AB" ]    [ 7 ]
            HN.2    1/6875         [ "19AB" ]    [ 1 ]
            HS.2    36/275          [ "15A" ]    [ 2 ]
            He.2   37/9520         [ "14CD" ]    [ 3 ]
            J2.2      1/15         [ "10CD" ]    [ 3 ]
            J3.2    1/1080         [ "19AB" ]    [ 1 ]
           M12.2      4/99          [ "10A" ]    [ 1 ]
           M22.2      1/21         [ "11AB" ]    [ 1 ]
           McL.2      1/63 [ "15AB", "30AB" ] [ 3, 3 ]
            ON.2   1/84672         [ "31AB" ]    [ 1 ]
           Suz.2 661/46332          [ "14A" ]    [ 3 ]

Note that for S = McL, the bound σ′(G,s) for G = S.2 (in the second column) is worse than the bound for the simple group S.
The structures and multiplicities of the maximal subgroups containing s are as follows.

        gap> for entry in sporautinfo do
        >      DisplayProbGenMaxesInfo( CharacterTable( entry[1] ), entry[3] );
        > od;
        F3+.2, 29AB: F3+  (1)
                     frob  (1)
        Fi22.2, 16AB: Fi22  (1)
                      Fi22.2M4  (1)
                      (2x2^(1+8)):(U4(2):2x2)  (1)
                      2F4(2)'.2  (4)
                      2^(5+8):(S3xS6)  (1)
        HN.2, 19AB: HN  (1)
                    U3(8).6  (1)
        HS.2, 15A: HS  (1)
                   S8x2  (1)
                   5:4xS5  (1)
        He.2, 14CD: He  (1)
                    2^(1+6)_+.L3(2).2  (1)
                    7^2:2.L2(7).2  (1)
                    7^(1+2):(S3x6)  (1)
        J2.2, 10CD: J2  (1)
                    2^(1+4).S5  (1)
                    (A5xD10).2  (1)
                    5^2:(4xS3)  (1)
        J3.2, 19AB: J3  (1)
                    19:18  (1)
        M12.2, 10A: M12  (1)
                    (2^2xA5):2  (1)
        M22.2, 11AB: M22  (1)
                     L2(11).2  (1)
        McL.2, 15AB: McL  (1)
                     3^(1+4):4S5  (1)
                     Isoclinic(2.A8.2)  (1)
                     5^(1+2):(24:2)  (1)
        McL.2, 30AB: McL  (1)
                     3^(1+4):4S5  (1)
                     Isoclinic(2.A8.2)  (1)
                     5^(1+2):(24:2)  (1)
        ON.2, 31AB: ON  (1)
                    31:30  (1)
        Suz.2, 14A: Suz  (1)
                    J2.2x2  (2)
                    (A4xL3(4):2_3):2  (1)

Note that the maximal subgroups L2(19) of J3 do not extend to J3.2 and that a class of maximal subgroups of the type 19:18 appears in J3.2 whose intersection with J3 is not maximal in J3. Similarly, the maximal subgroups A6.22 of M12 do not extend to M12.2.
For the other six groups, we use individual computations.
In the case S = Fi24′, the unique maximal subgroup 29:14 that contains an element s of order 29 extends to a group of the type 29:28 in Fi24, which is a nonsplit extension of 29:14.

        gap> SigmaFromMaxes( CharacterTable( "Fi24'.2" ), "29AB",
        >        [ CharacterTable( "29:28" ) ], [ 1 ], "outer" );
        0

In the case S = Fi22, there are four classes of maximal subgroups that contain s of order 16. They extend to G = Fi22.2, and none of the novelties in G (i. e., subgroups of G that are maximal in G but whose intersections with S are not maximal in S) contains s, cf. [CCN+85,p. 163].

        gap> 16 in OrdersClassRepresentatives( CharacterTable( "U4(2).2" ) );
        false
        gap> 16 in OrdersClassRepresentatives( CharacterTable( "G2(3).2" ) );
        false

The character tables of three of the four extensions are available in the GAP Character Table Library. The permutation character on the cosets of the fourth extension can be obtained as the extension of the permutation character of S on the cosets of its maximal subgroup of the type 25+8:(S3 ×A6).

        gap> t2:= CharacterTable( "Fi22.2" );;
        gap> prim:= List( [ "Fi22.2M4", "(2x2^(1+8)):(U4(2):2x2)", "2F4(2)" ],
        >        n -> PossiblePermutationCharacters( CharacterTable( n ), t2 ) );;
        gap> t:= CharacterTable( "Fi22" );;
        gap> pi:= PossiblePermutationCharacters(
        >             CharacterTable( "2^(5+8):(S3xA6)" ), t );
        [ Character( CharacterTable( "Fi22" ), [ 3648645, 56133, 10629, 2245, 567,
              729, 405, 81, 549, 165, 133, 37, 69, 20, 27, 81, 9, 39, 81, 19, 1, 13,
              33, 13, 1, 0, 13, 13, 5, 1, 0, 0, 0, 8, 4, 0, 0, 9, 3, 15, 3, 1, 1, 1,
              1, 3, 3, 1, 0, 0, 0, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2 ] ) ]
        gap> torso:= CompositionMaps( pi[1], InverseMap( GetFusionMap( t, t2 ) ) );
        [ 3648645, 56133, 10629, 2245, 567, 729, 405, 81, 549, 165, 133, 37, 69, 20,
          27, 81, 9, 39, 81, 19, 1, 13, 33, 13, 1, 0, 13, 13, 5, 1, 0, 0, 0, 8, 4, 0,
          9, 3, 15, 3, 1, 1, 1, 3, 3, 1, 0, 0, 2, 1, 0, 0, 0, 0, 0, 0, 1, 1, 2 ]
        gap> ext:= PermChars( t2, rec( torso:= torso ) );;
        gap> Add( prim, ext );
        gap> prim:= Concatenation( prim );;  Length( prim );
        4
        gap> spos:= Position( OrdersClassRepresentatives( t2 ), 16 );;
        gap> List( prim, x -> x[ spos ] );
        [ 1, 1, 4, 1 ]
        gap> sigma:= ApproxP( prim, spos );;
        gap> Maximum( sigma{ Difference( PositionsProperty(
        >                        OrdersClassRepresentatives( t2 ), IsPrimeInt ),
        >                        ClassPositionsOfDerivedSubgroup( t2 ) ) } );
        251/3861

In the case S = HN, the unique maximal subgroup U3(8).3 that contains the fixed element s of order 19 extends to a group of the type U3(8).6 in HN.2.

        gap> SigmaFromMaxes( CharacterTable( "HN.2" ), "19AB",
        >        [ CharacterTable( "U3(8).6" ) ], [ 1 ], "outer" );
        1/6875

In the case S = HS, there are two classes of maximal subgroups that contain s of order 15. They extend to G = HS.2, and none of the novelties in G contains s (cf. [CCN+85,p. 80]).

        gap> SigmaFromMaxes( CharacterTable( "HS.2" ), "15A",
        >      [ CharacterTable( "S8x2" ),
        >        CharacterTable( "5:4" ) * CharacterTable( "A5.2" ) ], [ 1, 1 ],
        >      "outer" );
        36/275

In the case S = He, there are three classes of maximal subgroups that contain s in the class `14C`. They extend to G = He.2, and none of the novelties in G contains s (cf. [CCN+85,p. 104]). We compute the extensions of the corresponding primitive permutation characters of S.

        gap> t:= CharacterTable( "He" );;
        gap> t2:= CharacterTable( "He.2" );;
        gap> prim:= PrimitivePermutationCharacters( t );;
        gap> spos:= Position( AtlasClassNames( t ), "14C" );;
        gap> prim:= Filtered( prim, x -> x[ spos ] <> 0 );;
        gap> map:= InverseMap( GetFusionMap( t, t2 ) );;
        gap> torso:= List( prim, pi -> CompositionMaps( pi, map ) );
        [ [ 187425, 945, 449, 0, 21, 21, 25, 25, 0, 0, 5, 0, 0, 7, 1, 0, 0, 1, 0, 1,
              0, 0, 0, 0, 0, 0 ],
          [ 244800, 0, 64, 0, 84, 0, 0, 16, 0, 0, 4, 24, 45, 3, 4, 0, 0, 0, 0, 1, 0,
              0, 0, 0, 0, 0 ],
          [ 652800, 0, 512, 120, 72, 0, 0, 0, 0, 0, 8, 8, 22, 1, 0, 0, 0, 0, 0, 1, 0,
              0, 1, 1, 2, 0 ] ]
        gap> ext:= List( torso, x -> PermChars( t2, rec( torso:= x ) ) );
        [ [ Character( CharacterTable( "He.2" ), [ 187425, 945, 449, 0, 21, 21, 25,
                  25, 0, 0, 5, 0, 0, 7, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 315, 15,
                  0, 0, 3, 7, 7, 3, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0 ] ) ],
          [ Character( CharacterTable( "He.2" ), [ 244800, 0, 64, 0, 84, 0, 0, 16, 0,
                  0, 4, 24, 45, 3, 4, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 360, 0, 0, 0,
                  6, 0, 0, 0, 0, 0, 3, 2, 2, 0, 0, 0, 0, 0, 0 ] ) ],
          [ Character( CharacterTable( "He.2" ), [ 652800, 0, 512, 120, 72, 0, 0, 0,
                  0, 0, 8, 8, 22, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 2, 0, 480, 0, 120,
                  0, 12, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 1, 1 ] ) ] ]
        gap> spos:= Position( AtlasClassNames( t2 ), "14CD" );;
        gap> sigma:= ApproxP( Concatenation( ext ), spos );;
        gap> Maximum( sigma{ Difference( PositionsProperty(
        >                        OrdersClassRepresentatives( t2 ), IsPrimeInt ),
        >                        ClassPositionsOfDerivedSubgroup( t2 ) ) } );
        37/9520

In the case S = O′N, the two classes of maximal subgroups of the type L2(31) do not extend to G = O′N.2, and a class of novelties of the structure 31:30 appears (see [CCN+85,p. 132]).

        gap> SigmaFromMaxes( CharacterTable( "ON.2" ), "31AB",
        >        [ CharacterTable( "P:Q", [ 31, 30 ] ) ], [ 1 ], "outer" );
        1/84672

Now we consider also σ(G,[^s]), for suitable [^s] ∈ G \S; this yields lower bounds for the spread of the nonsimple groups G. (These results are shown in the last two columns of [BGK08,Table 9].)
As above, we use the known character tables of the maximal subgroups in order to compute the optimal choice for [^s] ∈ G \S. (We may use the function `ProbGenInfoSimple` although the groups are not simple; all we need is that the relevant maximal subgroups are self-normalizing.)

        gap> sporautinfo2:= [];;
        gap> for name in List( sporautinfo, x -> x[1] ) do
        >      Add( sporautinfo2, ProbGenInfoSimple( CharacterTable( name ) ) );
        >    od;
        gap> PrintFormattedArray( sporautinfo2 );
           F3+.2    19/5684  299        [ "42E" ]   [ 10 ]
          Fi22.2 1165/20592   17        [ "24G" ]    [ 3 ]
            HN.2     1/1425 1424        [ "24B" ]    [ 4 ]
            HS.2     21/550   26        [ "20C" ]    [ 4 ]
            He.2    33/4165  126        [ "24A" ]    [ 2 ]
            J2.2       1/15   14        [ "14A" ]    [ 1 ]
            J3.2   77/10260  133        [ "34A" ]    [ 1 ]
           M12.2    113/495    4        [ "12B" ]    [ 3 ]
           M22.2       8/33    4        [ "10A" ]    [ 4 ]
           McL.2      1/135  134        [ "22A" ]    [ 1 ]
            ON.2  61/109368 1792 [ "22A", "38A" ] [ 1, 1 ]
           Suz.2      1/351  350        [ "28A" ]    [ 1 ]
        gap> for entry in sporautinfo2 do
        >      DisplayProbGenMaxesInfo( CharacterTable( entry[1] ), entry[4] );
        > od;
        F3+.2, 42E: 2^12.M24  (2)
                    2^2.U6(2):S3x2  (1)
                    2^(3+12).(L3(2)xS6)  (2)
                    (S3xS3xG2(3)):2  (1)
                    S6xL2(8):3  (1)
                    7:6xS7  (1)
                    7^(1+2)_+:(6xS3).2  (2)
        Fi22.2, 24G: Fi22.2M4  (1)
                     2^(5+8):(S3xS6)  (1)
                     3^5:(2xU4(2).2)  (1)
        HN.2, 24B: 2^(1+8)_+.(A5xA5).2^2  (1)
                   5^2.5.5^2.4S5  (2)
                   HN.2M13  (1)
        HS.2, 20C: (2xA6.2^2).2  (1)
                   HS.2N5  (2)
                   5:4xS5  (1)
        He.2, 24A: 2^(1+6)_+.L3(2).2  (1)
                   S4xL3(2).2  (1)
        J2.2, 14A: L3(2).2x2  (1)
        J3.2, 34A: L2(17)x2  (1)
        M12.2, 12B: L2(11).2  (1)
                    D8.(S4x2)  (1)
                    3^(1+2):D8  (1)
        M22.2, 10A: M22.2M4  (1)
                    A6.2^2  (1)
                    L2(11).2  (2)
        McL.2, 22A: 2xM11  (1)
        ON.2, 22A: J1x2  (1)
        ON.2, 38A: J1x2  (1)
        Suz.2, 28A: (A4xL3(4):2_3):2  (1)

In the other six cases, we do not have the complete lists of primitive permutation characters, so we choose a suitable element [^s] for each group. It is sufficient to prescribe |[^s]|, as follows.

        gap> sporautchoices:= [
        >        [ "Fi22",  "Fi22.2",  42 ],
        >        [ "Fi24'", "Fi24'.2", 46 ],
        >        [ "He",    "He.2",    42 ],
        >        [ "HN",    "HN.2",    44 ],
        >        [ "HS",    "HS.2",    30 ],
        >        [ "ON",    "ON.2",    38 ], ];;

First we list the maximal subgroups of the corresponding simple groups that contain the square of [^s].

        gap> for triple in sporautchoices do
        >      tbl:= CharacterTable( triple[1] );
        >      tbl2:= CharacterTable( triple[2] );
        >      spos2:= PowerMap( tbl2, 2,
        >          Position( OrdersClassRepresentatives( tbl2 ), triple[3] ) );
        >      spos:= Position( GetFusionMap( tbl, tbl2 ), spos2 );
        >      DisplayProbGenMaxesInfo( tbl, AtlasClassNames( tbl ){ [ spos ] } );
        >    od;
        Fi22, 21A: O8+(2).3.2  (1)
                   S3xU4(3).2_2  (1)
                   A10.2  (1)
                   A10.2  (1)
        F3+, 23A: Fi23  (1)
                  F3+M7  (1)
        He, 21B: 3.A7.2  (1)
                 7^(1+2):(S3x3)  (1)
                 7:3xpsl(3,2)  (2)
        HN, 22A: 2.HS.2  (1)
        HS, 15A: A8.2  (1)
                 5:4xa5  (1)
        ON, 19B: L3(7).2  (1)
                 ONM2  (1)
                 J1  (1)

According to [CCN+85], exactly the following maximal subgroups of the simple group S in the above list do not extend to Aut(S): The two S10 type subgroups of Fi22 and the two L3(7).2 type subgroups of O′N.
Furthermore, the following maximal subgroups of Aut(S) with the property that the intersection with S is not maximal in S have to be considered whether they contain s′: G2(3).2 and 35:(2 ×U4(2).2) in Fi22.2. (Note that the order of the 71+2+:(3 ×D16) type subgroup in O′N.2 is obviously not divisible by 19.)

        gap> 42 in OrdersClassRepresentatives( CharacterTable( "G2(3).2" ) );
        false
        gap> Size( CharacterTable( "U4(2)" ) ) mod 7 = 0;
        false

So we take the extensions of the above maximal subgroups, as described in [CCN+85].

        gap> SigmaFromMaxes( CharacterTable( "Fi22.2" ), "42A",
        >     [ CharacterTable( "O8+(2).3.2" ) * CharacterTable( "Cyclic", 2 ),
        >       CharacterTable( "S3" ) * CharacterTable( "U4(3).(2^2)_{122}" ) ],
        >     [ 1, 1 ] );
        163/1170
        gap> SigmaFromMaxes( CharacterTable( "Fi24'.2" ), "46A",
        >      [ CharacterTable( "Fi23" ) * CharacterTable( "Cyclic", 2 ),
        >        CharacterTable( "2^12.M24" ) ],
        >      [ 1, 1 ] );
        566/5481
        gap> SigmaFromMaxes( CharacterTable( "He.2" ), "42A",
        >      [ CharacterTable( "3.A7.2" ) * CharacterTable( "Cyclic", 2 ),
        >        CharacterTable( "7^(1+2):(S3x6)" ),
        >        CharacterTable( "7:6" ) * CharacterTable( "L3(2)" ) ],
        >      [ 1, 1, 1 ] );
        1/119
        gap> SigmaFromMaxes( CharacterTable( "HN.2" ), "44A",
        >      [ CharacterTable( "4.HS.2" ) ],
        >      [ 1 ] );
        997/192375
        gap> SigmaFromMaxes( CharacterTable( "HS.2" ), "30A",
        >      [ CharacterTable( "S8" ) * CharacterTable( "C2" ),
        >        CharacterTable( "5:4" ) * CharacterTable( "S5" ) ],
        >      [ 1, 1 ] );
        36/275
        gap> SigmaFromMaxes( CharacterTable( "ON.2" ), "38A",
        >      [ CharacterTable( "J1" ) * CharacterTable( "C2" ) ],
        >      [ 1 ] );
        61/109368

### 4.3 Other Simple Groups - Easy Cases

We are interested in simple groups G for which `ProbGenInfoSimple` does not guarantee S(G) ≥ 3. So we examine the remaining tables of simple groups in the GAP Character Table Library, and distinguish the following three cases: Either `ProbGenInfoSimple` yields the lower bound at least three, or a smaller bound, or the computation of a lower bound fails because not enough information is available to compute the primitive permutation characters.

        gap> names:= AllCharacterTableNames( IsSimple, true,
        >                                    IsDuplicateTable, false );;
        gap> names:= Difference( names, spornames );;
        gap> fails:= [];;
        gap> lessthan3:= [];;
        gap> atleast3:= [];;
        gap> for name in names do
        >      tbl:= CharacterTable( name );
        >      info:= ProbGenInfoSimple( tbl );
        >      if info = fail then
        >        Add( fails, name );
        >      elif info[3] < 3 then
        >        Add( lessthan3, info );
        >      else
        >        Add( atleast3, info );
        >      fi;
        >    od;

For the following simple groups, (currently) not enough information is available in the GAP Character Table Library and in the GAP Library of Tables of Marks, for computing a lower bound for σ(G). Some of these groups will be dealt with in later sections, and for the other groups, the bounds derived with theoretical arguments in [BGK08] are sufficient, so we need no GAP computations for them.

        gap> fails;
        [ "2E6(2)", "2F4(8)", "A14", "A15", "A16", "A17", "A18", "E6(2)", "F4(2)",
          "L4(4)", "L4(5)", "L4(9)", "L5(3)", "L6(2)", "L8(2)", "O10+(2)", "O10-(2)",
          "O10-(3)", "O7(5)", "O8-(3)", "O9(3)", "R(27)", "S10(2)", "S12(2)",
          "S4(7)", "S4(8)", "S4(9)", "S6(4)", "S6(5)", "S8(3)", "U4(4)", "U4(5)",
          "U5(3)", "U5(4)", "U7(2)" ]

The following simple groups appear in [BGK08,Table 1-6]. More detailed computations can be found in the sections 5.2, 5.3, 5.4, 5.12, 5.13, 5.20, 5.23, 5.24.

        gap> PrintFormattedArray( lessthan3 );
              A5      1/3 2                [ "5A" ]       [ 1 ]
              A6      2/3 1                [ "5A" ]       [ 2 ]
              A7      2/5 2                [ "7A" ]       [ 2 ]
           O7(3)  199/351 1               [ "14A" ]       [ 3 ]
          O8+(2)  334/315 0 [ "15A", "15B", "15C" ] [ 7, 7, 7 ]
          O8+(3) 863/1820 2 [ "20A", "20B", "20C" ] [ 8, 8, 8 ]
           S6(2)      4/7 1                [ "9A" ]       [ 4 ]
           S8(2)     8/15 1               [ "17A" ]       [ 3 ]
           U4(2)    21/40 1               [ "12A" ]       [ 2 ]
           U4(3)   53/135 2                [ "7A" ]       [ 7 ]

For the following simple groups G, the inequality σ(G) < 1/3 follows from the loop above. The columns show the name of G, the values σ(G) and S(G), the class names of s for which these values are attained, and |M(G,s)|.
(The entry for the group L7(2) would not fit on one screen line, so we show it independently.)

        gap> PrintFormattedArray( Filtered( atleast3, l -> l[1] <> "L7(2)" ) );
          2F4(2)' 118/1755   14                           [ "16A" ]             [ 2 ]
           3D4(2)   1/5292 5291                           [ "13A" ]             [ 1 ]
              A10     3/10    3                           [ "21A" ]             [ 1 ]
              A11    2/105   52                           [ "11A" ]             [ 2 ]
              A12      2/9    4                           [ "35A" ]             [ 1 ]
              A13   4/1155  288                           [ "13A" ]             [ 5 ]
               A8     3/14    4                           [ "15A" ]             [ 1 ]
               A9     9/35    3                      [ "9A", "9B" ]          [ 4, 4 ]
            G2(3)      1/7    6                           [ "13A" ]             [ 3 ]
            G2(4)     1/21   20                           [ "13A" ]             [ 2 ]
            G2(5)     1/31   30                     [ "7A", "21A" ]         [ 10, 1 ]
          L2(101)    1/101  100                    [ "51A", "17A" ]          [ 1, 1 ]
          L2(103)  53/5253   99             [ "52A", "26A", "13A" ]       [ 1, 1, 1 ]
          L2(107)  55/5671  103 [ "54A", "27A", "18A", "9A", "6A" ] [ 1, 1, 1, 1, 1 ]
          L2(109)    1/109  108                    [ "55A", "11A" ]          [ 1, 1 ]
           L2(11)     7/55    7                            [ "6A" ]             [ 1 ]
          L2(113)    1/113  112                    [ "57A", "19A" ]          [ 1, 1 ]
          L2(121)    1/121  120                           [ "61A" ]             [ 1 ]
          L2(125)    1/125  124        [ "63A", "21A", "9A", "7A" ]    [ 1, 1, 1, 1 ]
           L2(13)     1/13   12                            [ "7A" ]             [ 1 ]
           L2(16)     1/15   14                           [ "17A" ]             [ 1 ]
           L2(17)     1/17   16                            [ "9A" ]             [ 1 ]
           L2(19)   11/171   15                           [ "10A" ]             [ 1 ]
           L2(23)   13/253   19                     [ "6A", "12A" ]          [ 1, 1 ]
           L2(25)     1/25   24                           [ "13A" ]             [ 1 ]
           L2(27)    5/117   23                     [ "7A", "14A" ]          [ 1, 1 ]
           L2(29)     1/29   28                           [ "15A" ]             [ 1 ]
           L2(31)   17/465   27                     [ "8A", "16A" ]          [ 1, 1 ]
           L2(32)     1/31   30              [ "3A", "11A", "33A" ]       [ 1, 1, 1 ]
           L2(37)     1/37   36                           [ "19A" ]             [ 1 ]
           L2(41)     1/41   40                     [ "21A", "7A" ]          [ 1, 1 ]
           L2(43)   23/903   39                    [ "22A", "11A" ]          [ 1, 1 ]
           L2(47)  25/1081   43        [ "24A", "12A", "8A", "6A" ]    [ 1, 1, 1, 1 ]
           L2(49)     1/49   48                           [ "25A" ]             [ 1 ]
           L2(53)     1/53   52                     [ "27A", "9A" ]          [ 1, 1 ]
           L2(59)  31/1711   55       [ "30A", "15A", "10A", "6A" ]    [ 1, 1, 1, 1 ]
           L2(61)     1/61   60                           [ "31A" ]             [ 1 ]
           L2(64)     1/63   62                    [ "65A", "13A" ]          [ 1, 1 ]
           L2(67)  35/2211   63                    [ "34A", "17A" ]          [ 1, 1 ]
           L2(71)  37/2485   67 [ "36A", "18A", "12A", "9A", "6A" ] [ 1, 1, 1, 1, 1 ]
           L2(73)     1/73   72                           [ "37A" ]             [ 1 ]
           L2(79)  41/3081   75       [ "40A", "20A", "10A", "8A" ]    [ 1, 1, 1, 1 ]
            L2(8)      1/7    6                      [ "3A", "9A" ]          [ 1, 1 ]
           L2(81)     1/81   80                           [ "41A" ]             [ 1 ]
           L2(83)  43/3403   79 [ "42A", "21A", "14A", "7A", "6A" ] [ 1, 1, 1, 1, 1 ]
           L2(89)     1/89   88              [ "45A", "15A", "9A" ]       [ 1, 1, 1 ]
           L2(97)     1/97   96                     [ "49A", "7A" ]          [ 1, 1 ]
           L3(11)   1/6655 6654                   [ "19A", "133A" ]          [ 1, 1 ]
            L3(2)      1/4    3                            [ "7A" ]             [ 1 ]
            L3(3)     1/24   23                           [ "13A" ]             [ 1 ]
            L3(4)      1/5    4                            [ "7A" ]             [ 3 ]
            L3(5)    1/250  249                           [ "31A" ]             [ 1 ]
            L3(7)   1/1372 1371                           [ "19A" ]             [ 1 ]
            L3(8)   1/1792 1791                           [ "73A" ]             [ 1 ]
            L3(9)   1/2880 2879                           [ "91A" ]             [ 1 ]
            L4(3)  53/1053   19                           [ "20A" ]             [ 1 ]
            L5(2)   1/5376 5375                           [ "31A" ]             [ 1 ]
           O8-(2)     1/63   62                           [ "17A" ]             [ 1 ]
            S4(4)     4/15    3                           [ "17A" ]             [ 2 ]
            S4(5)      1/5    4                           [ "13A" ]             [ 1 ]
            S6(3)    1/117  116                           [ "14A" ]             [ 2 ]
           Sz(32)   1/1271 1270                     [ "5A", "25A" ]          [ 1, 1 ]
            Sz(8)     1/91   90                            [ "5A" ]             [ 1 ]
           U3(11)   1/6655 6654                           [ "37A" ]             [ 1 ]
            U3(3)    16/63    3                     [ "6A", "12A" ]          [ 2, 2 ]
            U3(4)    1/160  159                           [ "13A" ]             [ 1 ]
            U3(5)   46/525   11                           [ "10A" ]             [ 2 ]
            U3(7)   1/1372 1371                           [ "43A" ]             [ 1 ]
            U3(8)   1/1792 1791                           [ "19A" ]             [ 1 ]
            U3(9)   1/3600 3599                           [ "73A" ]             [ 1 ]
            U5(2)     1/54   53                           [ "11A" ]             [ 1 ]
            U6(2)     5/21    4                           [ "11A" ]             [ 4 ]
        gap> First( atleast3, l -> l[1] = "L7(2)" );
        [ "L7(2)", 1/4388290560, 4388290559, [ "127A" ], [ 1 ] ]

It should be mentioned that [BW75] states the following lower bounds for the uniform spread of the groups L2(q).

q−2

if 4 ≤ q is even,

q−1

if 11 ≤ q ≡ 1 mod 4,

q−4

if 11 ≤ q ≡ −1 mod 4.

These bounds appear in the third column of the above table. Furthermore, [BW75] states that the (uniform) spread of alternating groups of even degree at least 8 is exactly 4.
For the sake of completeness, Table 2 gives an overview of the sets M(G,s) for those cases in the above list that are needed in [BGK08] but that do not require a further discussion here. The structure of the maximal subgroups and the order of s in the table refer to the matrix groups not to the simple groups. The number of the subgroups has been shown above, the structure follows from [CCN+85].
Table 2: Maximal subgroups

G

M(G,s)

|s|

see [CCN+85]

SL(3,4) = 3.L3(4)

3 ×L3(2), 3 ×L3(2), 3 ×L3(2)

21

p. 23

Ω−(8,2) = O−8(2)

Ω−(4,4).2 = L2(16).2

17

p. 89

Sp(4,4) = S4(4)

Ω−(4,4).2 = L2(16).2, Sp(2,16).2 = L2(16).2

17

p. 44

Sp(6,3) = 2.S6(3)

(4 ×U3(3)).2, Sp(2,17).3 = 2.L2(27).3

28

p. 113

SU(3,3) = U3(3)

31+2+:8, GU(2,3) = 4.S4

6

p. 14

SU(3,5) = 3.U3(5)

3 ×51+2+:8, GU(2,5) = 3 ×2S5

30

p. 34

SU(5,2) = U5(2)

L2(11)

11

p. 73

### 4.4 Automorphism Groups of other Simple Groups - Easy Cases

We deal with automorphic extensions of those simple groups that are listed in Table 1 and that have been treated successfully in Section 4.3.
For the following groups, `ProbGenInfoAlmostSimple` can be used because GAP can compute their primitive permutation characters.

        gap> list:= [
        >   [ "A5", "A5.2" ],
        >   [ "A6", "A6.2_1" ],
        >   [ "A6", "A6.2_2" ],
        >   [ "A6", "A6.2_3" ],
        >   [ "A7", "A7.2" ],
        >   [ "A8", "A8.2" ],
        >   [ "A9", "A9.2" ],
        >   [ "A11", "A11.2" ],
        >   [ "L3(2)", "L3(2).2" ],
        >   [ "L3(3)", "L3(3).2" ],
        >   [ "L3(4)", "L3(4).2_1" ],
        >   [ "L3(4)", "L3(4).2_2" ],
        >   [ "L3(4)", "L3(4).2_3" ],
        >   [ "L3(4)", "L3(4).3" ],
        >   [ "S4(4)", "S4(4).2" ],
        >   [ "U3(3)", "U3(3).2" ],
        >   [ "U3(5)", "U3(5).2" ],
        >   [ "U3(5)", "U3(5).3" ],
        >   [ "U4(2)", "U4(2).2" ],
        >   [ "U4(3)", "U4(3).2_1" ],
        >   [ "U4(3)", "U4(3).2_3" ],
        > ];;
        gap> autinfo:= [];;
        gap> fails:= [];;
        gap> for pair in list do
        >      tbl:= CharacterTable( pair[1] );
        >      tblG:= CharacterTable( pair[2] );
        >      info:= ProbGenInfoSimple( tbl );
        >      spos:= List( info[4], x -> Position( AtlasClassNames( tbl ), x ) );
        >      Add( autinfo, ProbGenInfoAlmostSimple( tbl, tblG, spos ) );
        >    od;
        gap> PrintFormattedArray( autinfo );
               A5.2      0        [ "5AB" ]    [ 1 ]
             A6.2_1    2/3        [ "5AB" ]    [ 2 ]
             A6.2_2    1/6         [ "5A" ]    [ 1 ]
             A6.2_3      0        [ "5AB" ]    [ 1 ]
               A7.2   1/15        [ "7AB" ]    [ 1 ]
               A8.2  13/28       [ "15AB" ]    [ 1 ]
               A9.2    1/4        [ "9AB" ]    [ 1 ]
              A11.2  1/945       [ "11AB" ]    [ 1 ]
            L3(2).2    1/4        [ "7AB" ]    [ 1 ]
            L3(3).2   1/18       [ "13AB" ]    [ 1 ]
          L3(4).2_1   3/10        [ "7AB" ]    [ 3 ]
          L3(4).2_2  11/60         [ "7A" ]    [ 1 ]
          L3(4).2_3   1/12        [ "7AB" ]    [ 1 ]
            L3(4).3   1/64         [ "7A" ]    [ 1 ]
            S4(4).2      0       [ "17AB" ]    [ 2 ]
            U3(3).2    2/7 [ "6A", "12AB" ] [ 2, 2 ]
            U3(5).2   2/21        [ "10A" ]    [ 2 ]
            U3(5).3 46/525        [ "10A" ]    [ 2 ]
            U4(2).2  16/45       [ "12AB" ]    [ 2 ]
          U4(3).2_1 76/135         [ "7A" ]    [ 3 ]
          U4(3).2_3 31/162        [ "7AB" ]    [ 3 ]

We see that from this list, the two groups A6.21 = S6 and U4(3).21 require further computations (see Sections 5.3 and 5.24, respectively) because the bound in the second column is larger than 1/2.
Also U4(2) is not done by the above, because in [BGK08,Table 4], an element s of order 9 is chosen for the simple group, see Section 5.23.
Finally, we deal with automorphic extensions of the groups L4(3), O8−(2), S6(3), and U5(2).
For S = L4(3) and s ∈ S of order 20, we have M(S,s) = { (4 ×A6):2 }, the subgroup has index 2 106, see [CCN+85,p. 69].

        gap> t:= CharacterTable( "L4(3)" );;
        gap> prim:= PrimitivePermutationCharacters( t );;
        gap> spos:= Position( AtlasClassNames( t ), "20A" );;
        gap> prim:= Filtered( prim, x -> x[ spos ] <> 0 );
        [ Character( CharacterTable( "L4(3)" ), [ 2106, 106, 42, 0, 27, 27, 0, 46, 6,
              6, 1, 7, 7, 0, 3, 3, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1 ] ) ]

For the three automorphic extensions of the structure G = S.2, we compute the extensions of the permutation character, and the bounds σ′(G,s).

        gap> for name in [ "L4(3).2_1", "L4(3).2_2", "L4(3).2_3" ] do
        >      t2:= CharacterTable( name );
        >      map:= InverseMap( GetFusionMap( t, t2 ) );
        >      torso:= List( prim, pi -> CompositionMaps( pi, map ) );
        >      ext:= Concatenation( List( torso,
        >                              x -> PermChars( t2, rec( torso:= x ) ) ) );
        >      sigma:= ApproxP( ext, Position( OrdersClassRepresentatives( t2 ), 20 ) );
        >      max:= Maximum( sigma{ Difference( PositionsProperty(
        >                           OrdersClassRepresentatives( t2 ), IsPrimeInt ),
        >                           ClassPositionsOfDerivedSubgroup( t2 ) ) } );
        >      Print( name, ":\n", ext, "\n", max, "\n" );
        > od;
        L4(3).2_1:
        [ Character( CharacterTable( "L4(3).2_1" ), [ 2106, 106, 42, 0, 27, 0, 46, 6,
              6, 1, 7, 0, 3, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 4, 0, 0, 6, 6, 6, 6,
              2, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1 ] ) ]
        0
        L4(3).2_2:
        [ Character( CharacterTable( "L4(3).2_2" ),
            [ 2106, 106, 42, 0, 27, 27, 0, 46, 6, 6, 1, 7, 7, 0, 3, 3, 0, 0, 0, 1, 1,
              1, 0, 0, 0, 1, 306, 306, 42, 6, 10, 10, 0, 0, 15, 15, 3, 3, 3, 3, 0, 0,
              1, 1, 0, 1, 1, 0, 0 ] ) ]
        17/117
        L4(3).2_3:
        [ Character( CharacterTable( "L4(3).2_3" ), [ 2106, 106, 42, 0, 27, 0, 46, 6,
              6, 1, 7, 0, 3, 0, 0, 1, 1, 0, 0, 0, 1, 36, 0, 0, 6, 6, 2, 2, 2, 1, 1,
              0, 0, 0 ] ) ]
        2/117

For S = O8−(2) and s ∈ S of order 17, we have M(S,s) = { L2(16).2 }, the subgroup extends to L2(16).4 in S.2, see [CCN+85,p. 89]. This is a non-split extension, so σ′(S.2,s) = 0 holds.

        gap> SigmaFromMaxes( CharacterTable( "O8-(2).2" ), "17AB",
        >        [ CharacterTable( "L2(16).4" ) ], [ 1 ], "outer" );
        0

For S = S6(3) and s ∈ S irreducible of order 14, we have M(S,s) = { (2 ×U3(3)).2, L2(27).3 }. In G = S.2, the subgroups extend to (4 ×U3(3)).2 and L2(27).6, respectively, see [CCN+85,p. 113]. In order to show that σ′(G,s) = 7/3240 holds, we compute the primitive permutation characters of S (cf. Section 4.3) and the unique extensions to G of those which are nonzero on s.

        gap> t:= CharacterTable( "S6(3)" );;
        gap> t2:= CharacterTable( "S6(3).2" );;
        gap> prim:= PrimitivePermutationCharacters( t );;
        gap> spos:= Position( AtlasClassNames( t ), "14A" );;
        gap> prim:= Filtered( prim, x -> x[ spos ] <> 0 );;
        gap> map:= InverseMap( GetFusionMap( t, t2 ) );;
        gap> torso:= List( prim, pi -> CompositionMaps( pi, map ) );;
        gap> ext:= List( torso, pi -> PermChars( t2, rec( torso:= pi ) ) );
        [ [ Character( CharacterTable( "S6(3).2" ), [ 155520, 0, 288, 0, 0, 0, 216,
                  54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 0, 6,
                  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 144,
                  288, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 1, 1, 1,
                  1, 0, 0 ] ) ],
          [ Character( CharacterTable( "S6(3).2" ), [ 189540, 1620, 568, 0, 486, 0,
                  0, 27, 540, 84, 24, 0, 0, 0, 0, 0, 54, 0, 0, 10, 0, 7, 1, 6, 6, 0,
                  0, 0, 0, 0, 0, 18, 0, 0, 0, 6, 12, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
                  0, 0, 234, 64, 30, 8, 0, 3, 90, 6, 0, 4, 10, 6, 0, 2, 1, 0, 0, 0,
                  0, 0, 0, 0, 1, 1, 0, 0 ] ) ] ]
        gap> spos:= Position( AtlasClassNames( t2 ), "14A" );;
        gap> sigma:= ApproxP( Concatenation( ext ), spos );;
        gap> Maximum( sigma{ Difference(
        >      PositionsProperty( OrdersClassRepresentatives( t2 ), IsPrimeInt ),
        >      ClassPositionsOfDerivedSubgroup( t2 ) ) } );
        7/3240

For S = U5(2) and s ∈ S of order 11, we have M(S,s) = { L2(11) }, the subgroup extends to L2(11).2 in S.2, see [CCN+85,p. 73].

        gap> SigmaFromMaxes( CharacterTable( "U5(2).2" ), "11AB",
        >        [ CharacterTable( "L2(11).2" ) ], [ 1 ], "outer" );
        1/288

Here we clean the workspace for the first time. This may save more than 100 megabytes, due to the fact that the caches for tables of marks and character tables are flushed.

        gap> CleanWorkspace();

### 4.5 O8−(3)

We show that S = O8−(3) = Ω−(8,3) satisfies the following.

(a) For s ∈ S of order 41, M(S,s) consists of one group of the type L2(81).21 = Ω−(4,9).2.
(b) σ(S,s) = 1/567.

The only maximal subgroups of S containing elements of order 41 have the type L2(81).21, and there is one class of these subgroups, see [CCN+85,p. 141].

        gap> SigmaFromMaxes( CharacterTable( "O8-(3)" ), "41A",
        >    [ CharacterTable( "L2(81).2_1" ) ], [ 1 ] );
        1/567

### 4.6 O10+(2)

We show that S = O10+(2) = Ω+(10,2) satisfies the following.

(a) For s ∈ S of order 45, M(S,s) consists of one group of the type (A5 ×U4(2)).2 = (Ω−(4,2) ×Ω−(6,2)).2.
(b) σ(S,s) = 43/4 216.
(c) For s as in (a), the maximal subgroup in (a) extends to S5 ×U4(2).2 in G = Aut(S) = S.2, and σ′(G,s) = 23/248.

The only maximal subgroups of S containing elements of order 45 are one class of groups H = (A5 ×U4(2)):2, see [CCN+85,p. 146]. (Note that none of the groups S8(2), O8+(2), L5(2), O8−(2), and A8 contains elements of order 45.) H extends to subgroups of the type H.2 = S5 ×U4(2):2 in G, so we can compute 1HS = (1H.2G)S.

        gap> ForAny( [ "S8(2)", "O8+(2)", "L5(2)", "O8-(2)", "A8" ],
        >            x -> 45 in OrdersClassRepresentatives( CharacterTable( x ) ) );
        false
        gap> t:= CharacterTable( "O10+(2)" );;
        gap> t2:= CharacterTable( "O10+(2).2" );;
        gap> s2:= CharacterTable( "A5.2" ) * CharacterTable( "U4(2).2" );
        CharacterTable( "A5.2xU4(2).2" )
        gap> pi:= PossiblePermutationCharacters( s2, t2 );;
        gap> spos:= Position( OrdersClassRepresentatives( t2 ), 45 );;
        gap> approx:= ApproxP( pi, spos );;
        gap> Maximum( approx{ ClassPositionsOfDerivedSubgroup( t2 ) } );
        43/4216

Statement (c) follows from considering the outer classes of prime element order.

        gap> Maximum( approx{ Difference(
        >      PositionsProperty( OrdersClassRepresentatives( t2 ), IsPrimeInt ),
        >      ClassPositionsOfDerivedSubgroup( t2 ) ) } );
        23/248

Alternatively, we can use `SigmaFromMaxes`.

        gap> SigmaFromMaxes( t2, "45AB", [ s2 ], [ 1 ], "outer" );
        23/248

### 4.7 O10−(2)

We show that S = O10−(2) = Ω−(10,2) satisfies the following.

(a) For s ∈ S of order 33, M(S,s) consists of one group of the type 3 ×U5(2) = GU(5,2).
(b) σ(S,s) = 1/119.
(c) For s as in (a), the maximal subgroup in (a) extends to (3 ×U5(2)).2 in G, and σ′(G,s) = 1/595.

The only maximal subgroups of S containing elements of order 11 have the types A12 and 3 ×U5(2), see [CCN+85,p. 147]. So 3 ×U5(2) is the unique class of subgroups containing elements of order 33. This shows statement (a), and statement (b) follows using `SigmaFromMaxes`.

        gap> SigmaFromMaxes( CharacterTable( "O10-(2)" ), "33A",
        >    [ CharacterTable( "Cyclic", 3 ) * CharacterTable( "U5(2)" ) ], [ 1 ] );
        1/119

The structure of the maximal subgroup of G follows from [CCN+85,p. 147]. We create its character table with a generic construction that is based on the fact that the outer automorphism acts nontrivially on the two direct factors; this determines the character table uniquely. (See [Breb] for details.)

        gap> tblG:= CharacterTable( "U5(2)" );;
        gap> tblMG:= CharacterTable( "Cyclic", 3 ) * tblG;;
        gap> tblGA:= CharacterTable( "U5(2).2" );;
        gap> acts:= PossibleActionsForTypeMGA( tblMG, tblG, tblGA );;
        gap> poss:= Concatenation( List( acts, pi ->
        >            PossibleCharacterTablesOfTypeMGA( tblMG, tblG, tblGA, pi,
        >                "(3xU5(2)).2" ) ) );
        [ rec( MGfusMGA := [ 1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 9, 10, 11, 12, 12, 13, 13,
                  14, 14, 15, 15, 16, 17, 17, 18, 18, 19, 20, 21, 21, 22, 22, 23, 23,
                  24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 30, 31, 32, 33, 34,
                  35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
                  52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
                  69, 70, 71, 72, 73, 74, 75, 76, 77, 31, 32, 33, 35, 34, 37, 36, 38,
                  39, 40, 41, 42, 43, 45, 44, 47, 46, 49, 48, 51, 50, 52, 54, 53, 56,
                  55, 57, 58, 60, 59, 62, 61, 64, 63, 66, 65, 68, 67, 69, 71, 70, 73,
                  72, 75, 74, 77, 76 ], table := CharacterTable( "(3xU5(2)).2" ) ) ]

Now statement (c) follows using `SigmaFromMaxes`.

        gap> SigmaFromMaxes( CharacterTable( "O10-(2).2" ), "33AB",
        >        [ poss[1].table ], [ 1 ], "outer" );
        1/595

### 4.8 O12+(2)

We show that S = O12+(2) = Ω+(12,2) satisfies the following.

(a) For s ∈ S of the type 4− ⊥8− (i. e., s decomposes the natural 12-dimensional module for GO+12(2) = S.2 into an orthogonal sum of two irreducible modules of the dimensions 4 and 8, respectively) and of order 85, M(S,s) consists of one group of the type G8 = (Ω−(4,2) ×Ω−(8,2)).2 and two groups of the type L4(4).22 = Ω+(6,4).22 that are conjugate in G = Aut(S) = S.2 = SO+(12,2) but not conjugate in S.
(b) σ(S,s) = 7 675/1 031 184.
(c) σ′(G,s) = 73/1 008.

The element s is a ppd(12,2;8)-element in the sense of [GPPS99], so the maximal subgroups of S that contain s are among the nine cases (2.1)-(2.9) listed in this paper; in the notation of this paper, we have q = 2, d = 12, e = 8, and r = 17. Case (2.1) does not occur for orthogonal groups and q = 2, according to [KL90]; case (2.2) contributes a unique maximal subgroup, the stabilizer G8 of the orthogonal decomposition; the cases (2.3), (2.4) (a), (2.5), and (2.6) (a) do not occur because r ≠ e+1 in our situation; case (2.4) (b) describes extension field type subgroups that are contained in ΓL(6,4), which yields the candidates GU(6,2).2 ≅ 3.U6(2).S3 -but 3.U6(2).3 does not contain elements of order 85- and Ω+(6,4).22 ≅ L4(4).22 (two classes by [KL90,Prop. 4.3.14]); the cases (2.6) (b)-(c) and (2.8) do not occur because they require d ≤ 8; case (2.7) does not occur because [GPPS99,Table 5] contains no entry for r = 2e+1 = 17; finally, case (2.9) does not occur because it requires e ∈ { d−1, d } in the case r = 2e+1.
So we need the permutation characters of the actions on the cosets of L4(4).22 (two classes) and G8. According to [KL90,Prop. 4.1.6], G8 has the structure (Ω−(4,2) ×Ω−(8,2)).2.
Currently the GAP Character Table Library does not contain the character table of S, but the table of G is available, and we work with this table.
The two classes of L4(4).22 type subgroups in S are fused in G. This can be seen from the fact that inducing the trivial character of a subgroup H1 = L4(4).22 of S to G yields a character ψ whose values are not all even; note that if H1 would extend in G to a subgroup of twice the size of H1 then ψ would be induced from a degree two character of this subgroup whose values are all even, and induction preserves this property.

        gap> CharacterTable( "O12+(2)" );
        fail
        gap> t:= CharacterTable( "O12+(2).2" );;
        gap> h1:= CharacterTable( "L4(4).2^2" );;
        gap> psi:= PossiblePermutationCharacters( h1, t );;
        gap> Length( psi );
        1
        gap> ForAny( psi[1], IsOddInt );
        true

The fixed element s of order 85 is contained in a member of each of the two conjugacy classes of the type L4(4).22 in S, since S contains only one class of subgroups of the order 85; note that the order of the Sylow 17 centralizer (in both S and G) is not divisible by 25.

        gap> SizesCentralizers( t ){ PositionsProperty(
        >        OrdersClassRepresentatives( t ), x -> x = 17 ) } / 25;
        [ 408/5, 408/5 ]

This implies that the restriction of ψ to S is the sum ψS = π1 + π2, say, of the first two interesting permutation characters of S.
The subgroup G8 of S extends to a group of the structure H2 = Ω−(4,2).2 ×Ω−(8,2).2 in G, inducing the trivial characters of H2 to G yields a permutation character ϕ of G whose restriction to S is the third permutation character ϕS = π3, say.

        gap> h2:= CharacterTable( "S5" ) * CharacterTable( "O8-(2).2" );;
        gap> phi:= PossiblePermutationCharacters( h2, t );;
        gap> Length( phi );
        1

We have π1(1) = π2(1) and π1(s) = π2(s), the latter again because S contains only one class of subgroups of order 85.
Now statement (a) follows from the fact that πi(s) = 1 holds for 1 ≤ i ≤ 3.

        gap> prim:= Concatenation( psi, phi );;
        gap> spos:= Position( OrdersClassRepresentatives( t ), 85 );
        213
        gap> List( prim, x -> x[ spos ] );
        [ 2, 1 ]

For statement (b), we compute σ(S,s). Note that we have to consider only classes inside S = G′, and that

σ( g, s ) =

3
∑
i=1

πi(s) ·πi(g)

πi(1)

=

ψ(s) ·ψ(g)

ψ(1)

+

ϕ(s) ·ϕ(g)

ϕ(1)

holds for g ∈ S×, so the characters ψ and ϕ are sufficient.

        gap> approx:= ApproxP( prim, spos );;
        gap> Maximum( approx{ ClassPositionsOfDerivedSubgroup( t ) } );
        7675/1031184

Statement (c) follows from considering the outer involution classes. Note that by [BGK08,Remark after Proposition 5.14], only the subgroup H2 need to be considered, no novelties appear.

        gap> Maximum( approx{ Difference(
        >      PositionsProperty( OrdersClassRepresentatives( t ), IsPrimeInt ),
        >      ClassPositionsOfDerivedSubgroup( t ) ) } );
        73/1008

### 4.9 O12−(2)

We show that S = O12−(2) = Ω−(12,2) satisfies the following.

(a) For s ∈ S irreducible of order 26+1 = 65, M(S,s) consists of two groups of the types U4(4).2 = Ω−(6,4).2 and L2(64).3 = Ω−(4,8).3, respectively.
(b) σ(S,s) = 1/1 023.
(c) σ′(Aut(S),s) = 1/347 820.

By [Ber00], M(S,s) consists of extension field subgroups, which have the structures U4(4).2 and L2(64).3, respectively, and by [KL90,Prop. 4.3.16], there is just one class of each of these types.
Currently the GAP Character Table Library does not contain the character table of S, but the table of G = Aut(S) = O12−(2).2 is available. So we compute the permutation characters π1, π2 of the extensions of the groups in M(S,s) to G -these maximal subgroups have the structures U4(4).4 and L2(64).6, respectively- and compute the fixed point ratios of the restrictions to S.

        gap> t:= CharacterTable( "O12-(2)" );
        fail
        gap> t:= CharacterTable( "O12-(2).2" );;
        gap> s1:= CharacterTable( "U4(4).4" );;
        gap> pi1:= PossiblePermutationCharacters( s1, t );;
        gap> s2:= CharacterTable( "L2(64).6" );;
        gap> pi2:= PossiblePermutationCharacters( s2, t );;
        gap> prim:= Concatenation( pi1, pi2 );;  Length( prim );
        2

Now statement (a) follows from the fact that π1(s) = π2(s) = 1 holds.

        gap> spos:= Position( OrdersClassRepresentatives( t ), 65 );;
        gap> List( prim, x -> x[ spos ] );
        [ 1, 1 ]

For statement (b), we compute σ(S,s); note that we have to consider only classes inside S = G′.

        gap> approx:= ApproxP( prim, spos );;
        gap> Maximum( approx{ ClassPositionsOfDerivedSubgroup( t ) } );
        1/1023

Statement (c) follows from the values on the outer involution classes.

        gap> Maximum( approx{ Difference(
        >      PositionsProperty( OrdersClassRepresentatives( t ), IsPrimeInt ),
        >      ClassPositionsOfDerivedSubgroup( t ) ) } );
        1/347820

### 4.10 S6(4)

We show that S = S6(4) = Sp(6,4) satisfies the following.

(a) For s ∈ S irreducible of order 65, M(S,s) consists of two groups of the types U4(4).2 = Ω−(6,4).2 and L2(64).3 = Sp(2,64).3, respectively.
(b) σ(S,s) = 16/63.
(c) σ′(Aut(S),s) = 0.

By [Ber00], the element s is contained in maximal subgroups of the given types, and by [KL90,Prop. 4.3.10, 4.8.6], there is exactly one class of these subgroups.
The character tables of these two subgroups are currently not contained in the GAP Character Table Library. We compute the permutation character induced from the first subgroup as the unique character of the right degree that is combinatorially possible (cf. [BP98]).

        gap> t:= CharacterTable( "S6(4)" );;
        gap> degree:= Size( t ) / ( 2 * Size( CharacterTable( "U4(4)" ) ) );;
        gap> pi1:= PermChars( t, rec( torso:= [ degree ] ) );;
        gap> Length( pi1 );
        1

The index of the second subgroup is too large for this simpleminded approach; therefore, we first restrict the set of possible irreducible constituents of the permutation character to those of 1HG, where H is the derived subgroup of L2(64).3, for which the character table is available.

        gap> CharacterTable( "L2(64).3" );  CharacterTable( "U4(4).2" );
        fail
        fail
        gap> s:= CharacterTable( "L2(64)" );;
        gap> subpi:= PossiblePermutationCharacters( s, t );;
        gap> Length( subpi );
        1
        gap> scp:= MatScalarProducts( t, Irr( t ), subpi );;
        gap> nonzero:= PositionsProperty( scp[1], x -> x <> 0 );
        [ 1, 11, 13, 14, 17, 18, 32, 33, 56, 58, 59, 73, 74, 77, 78, 79, 80, 93, 95,
          96, 103, 116, 117, 119, 120 ]
        gap> const:= RationalizedMat( Irr( t ){ nonzero } );;
        gap> degree:= Size( t ) / ( 3 * Size( s ) );
        5222400
        gap> pi2:= PermChars( t, rec( torso:= [ degree ], chars:= const ) );;
        gap> Length( pi2 );
        1
        gap> prim:= Concatenation( pi1, pi2 );;

Now statement (a) follows from the fact that π1(s) = π2(s) = 1 holds.

        gap> spos:= Position( OrdersClassRepresentatives( t ), 65 );;
        gap> List( prim, x -> x[ spos ] );
        [ 1, 1 ]

For statement (b), we compute σ(G,s).

        gap> Maximum( ApproxP( prim, spos ) );
        16/63

In order to prove statement (c), we have to consider only the extensions of the above permutation characters of S to Aut(S) ≅ S.2 (cf. [BGK08,Section 2.2]).

        gap> t2:= CharacterTable( "S6(4).2" );;
        gap> tfust2:= GetFusionMap( t, t2 );;
        gap> cand:= List( prim, x -> CompositionMaps( x, InverseMap( tfust2 ) ) );;
        gap> ext:= List( cand, pi -> PermChars( t2, rec( torso:= pi ) ) );
        [ [ Character( CharacterTable( "S6(4).2" ), [ 2016, 512, 96, 128, 32, 120, 0,
                  6, 16, 40, 24, 0, 8, 136, 1, 6, 6, 1, 32, 0, 8, 6, 2, 0, 2, 0, 0,
                  4, 0, 16, 32, 1, 8, 2, 6, 2, 1, 2, 4, 0, 0, 1, 6, 0, 1, 10, 0, 1,
                  1, 0, 10, 10, 4, 0, 1, 0, 2, 0, 2, 1, 2, 2, 1, 1, 0, 0, 0, 1, 1, 1,
                  1, 0, 0, 0, 0, 0, 32, 0, 0, 8, 0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 8, 0,
                  0, 0, 2, 2, 0, 2, 2, 0, 2, 2, 2, 0, 0 ] ) ],
          [ Character( CharacterTable( "S6(4).2" ), [ 5222400, 0, 0, 0, 1280, 0, 960,
                  120, 0, 0, 0, 0, 0, 0, 1600, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 1, 0, 0,
                  15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 10, 0,
                  0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0,
                  0, 0, 0, 960, 0, 0, 0, 16, 0, 24, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                  0, 0, 4, 1, 0, 0, 3, 0, 0, 0, 0, 0 ] ) ] ]
        gap> spos2:= Position( OrdersClassRepresentatives( t2 ), 65 );;
        gap> sigma:= ApproxP( Concatenation( ext ), spos2 );;
        gap> Maximum( approx{ Difference(
        >      PositionsProperty( OrdersClassRepresentatives( t2 ), IsPrimeInt ),
        >      ClassPositionsOfDerivedSubgroup( t2 ) ) } );
        0

For the simple group, we can alternatively consider a reducible element s: 2 ⊥4 of order 85, which is a multiple of the primitive prime divisor r = 17 of 44−1. So we have e = 4, d = 6, and q = 4, in the terminology of [GPPS99]. Then M(S,s) consists of two groups, of the types Ω+(6,4).2 ≅ L4(4).22 and Sp(2,4) ×Sp(4,4). This can be shown by checking [GPPS99,Ex. 2.1-2.9]. Ex. 2.1 yields the candidates Ω±(6,4).2, but only Ω+(6,4).2 contains elements of order 85. Ex. 2.2 yields the stabilizer of a two-dimensional subspace, which has the structure Sp(2,4) ×Sp(4,4), by [KL90]. All other cases except Ex. 2.4 (b) are excluded by the fact that r = 4e+1, and Ex. 2.4 (b) does not apply because d/gcd(d,e) is odd.

        gap> SigmaFromMaxes( CharacterTable( "S6(4)" ), "85A",
        >    [ CharacterTable( "L4(4).2_2" ),
        >      CharacterTable( "A5" ) * CharacterTable( "S4(4)" ) ], [ 1, 1 ] );
        142/455

This bound is not as good as the one obtained from the irreducible element of order 65 used above.

        gap> 16/63 < 142/455;
        true

### 4.11 ∗ S6(5)

We show that S = S6(5) = PSp(6,5) satisfies the following.

(a) For s ∈ S of the type 2 ⊥4 (i. e., the preimage of s in Sp(6,5) = 2.G decomposes the natural 6-dimensional module for Sp(6,5) into an orthogonal sum of two irreducible modules of the dimensions 2 and 4, respectively) and of order 78, M(S,s) consists of one group of the type G2 = 2.(PSp(2,5) ×PSp(4,5)).
(b) σ(S,s) = 9/217.

The order of s is a multiple of the primitive prime divisor r = 13 of 54−1, so we have e = 4, d = 6, and q = 5, in the terminology of [GPPS99]. We check [GPPS99,Ex. 2.1-2.9]. Ex. 2.1 does not apply because the classes C5 and C8 are empty by [KL90,Table 3.5.C], Ex. 2.2 yields exactly the stabilizer G2 of a 2-dimensional subspace, Ex. 2.4 (b) does not apply because d/gcd(d,e) is odd, and all other cases are excluded by the fact that r = 3e+1.
The group G2 has the structure 2.(PSp(2,5) ×PSp(4,5)), which is a central product of Sp(2,5) ≅ 2.A5 and Sp(4,5) = 2.S4(5) (see [KL90,Prop. 4.1.3]). The character table of G2 can be derived from that of the direct product of 2.A5 and 2.S4(5), by factoring out the diagonal central subgroup of order two.

        gap> t:= CharacterTable( "S6(5)" );;
        gap> s1:= CharacterTable( "2.A5" );;
        gap> s2:= CharacterTable( "2.S4(5)" );;
        gap> dp:= s1 * s2;
        CharacterTable( "2.A5x2.S4(5)" )
        gap> c:= Difference( ClassPositionsOfCentre( dp ), Union(
        >                        GetFusionMap( s1, dp ), GetFusionMap( s2, dp ) ) );
        [ 62 ]
        gap> s:= dp / c;
        CharacterTable( "2.A5x2.S4(5)/[ 1, 62 ]" )

Now we compute σ(S,s).

        gap> SigmaFromMaxes( t, "78A", [ s ], [ 1 ] );
        9/217

### 4.12 S8(3)

We show that S = S8(3) = PSp(8,3) satisfies the following.

(a) For s ∈ S irreducible of order 41, M(S,s) consists of one group M of the type S4(9).2 = PSp(4,9).2.
(b) σ(S,s) = 1/546.
(c) The preimage of s in the matrix group 2.S8(3) = Sp(8,3) can be chosen of order 82, and the preimage of M is 2.S4(9).2 = Sp(4,9).2.

By [Ber00], the only maximal subgroups of S that contain irreducible elements of order (34+1)/2 = 41 are of extension field type, and by [KL90,Prop. 4.3.10], these groups have the structure S4(9).2 and there is exactly one class of these groups.
The group U = S4(9) has three nontrivial outer automorphisms, the character table of the subgroup U.2 in question has the identifier `"S4(9).2_1"`, which follows from the fact that the extensions of U by the other two outer automorphisms do not admit a class fusion into S.

        gap> t:= CharacterTable( "S8(3)" );;
        gap> pi:= List( [ "S4(9).2_1", "S4(9).2_2", "S4(9).2_3" ],
        >               name -> PossiblePermutationCharacters(
        >                           CharacterTable( name ), t ) );;
        gap> List( pi, Length );
        [ 1, 0, 0 ]

Now statement (a) follows from the fact that (1U.2)S(s) = 1 holds.

        gap> spos:= Position( OrdersClassRepresentatives( t ), 41 );;
        gap> pi[1][1][ spos ];
        1

Now we compute σ(S,s) in order to show statement (b).

        gap> Maximum( ApproxP( pi[1], spos ) );
        1/546

Statement (c) is clear from the description of extension field type subgroups in [KL90].

### 4.13 U4(4)

We show that S = U4(4) = SU(4,4) satisfies the following.

(a) For s ∈ S of the type 1 ⊥3 (i. e., s decomposes the natural 4-dimensional module for SU(4,4) into an orthogonal sum of two irreducible modules of the dimensions 1 and 3, respectively) and of order 43+1 = 65, M(S,s) consists of one group of the type G1 = 5 ×U3(4) = GU(3,4).
(b) σ(S,s) = 209/3 264.

By [MSW94], the only maximal subgroups of S that contain s are one class of stabilizers H ≅ 5 ×U3(4) of this decomposition, and clearly there is only one such group containing s.
Note that H has index 3 264 in S, since S has two orbits on the 1-dimensional subspaces, of lengths 1 105 and 3 264, respectively, and elements of order 13 = 65/5 lie in the stabilizers of points in the latter orbit.

        gap> g:= SU(4,4);;
        gap> orbs:= Orbits( g, NormedRowVectors( GF(16)^4 ), OnLines );;
        gap> orblen:= List( orbs, Length );
        [ 1105, 3264 ]
        gap> List( orblen, x -> x mod 13 );
        [ 0, 1 ]

We compute the permutation character 1G1S; there is exactly one combinatorially possible permutation character of degree 3 264 (cf. [BP98]).

        gap> t:= CharacterTable( "U4(4)" );;
        gap> pi:= PermChars( t, rec( torso:= [ orblen[2] ] ) );;
        gap> Length( pi );
        1

Now we compute σ(S,s).

        gap> spos:= Position( OrdersClassRepresentatives( t ), 65 );;
        gap> Maximum( ApproxP( pi, spos ) );
        209/3264

### 4.14 U6(2)

We show that S = U6(2) = PSU(6,2) satisfies the following.

(a) For s ∈ S of order 11, M(S,s) consists of one group of the type U5(2) = SU(5,2) and three groups of the type M22.
(b) σ(S,s) = 5/21.
(c) The preimage of s in the matrix group SU(6,2) = 3.U6(2) can be chosen of order 33, and the preimages of the groups in M(S,s) have the structures 3 ×U5(2) ≅ GU(5,2) and 3.M22, respectively.
(d) With s as in (a), the automorphic extensions S.2, S.3 of S satisfy σ′(S.2,s) = 5/96 and σ′(S.3,s) = 59/224.

According to the list of maximal subgroups of S in [CCN+85,p. 115], s is contained exactly in maximal subgroups of the types U5(2) (one class) and M22 (three classes).
The permutation character of the action on the cosets of U5(2) type subgroups is uniquely determined by the character tables. We get three possibilities for the permutation character on the cosets of M22 type subgroups; they correspond to the three classes of such subgroups, because each of these classes contains elements in exactly one of the conjugacy classes `4C`, `4D`, and `4E` of elements in S, and these classes are fused under the outer automorphism of S of order three.

        gap> t:= CharacterTable( "U6(2)" );;
        gap> s1:= CharacterTable( "U5(2)" );;
        gap> pi1:= PossiblePermutationCharacters( s1, t );;
        gap> Length( pi1 );
        1
        gap> s2:= CharacterTable( "M22" );;
        gap> pi2:= PossiblePermutationCharacters( s2, t );
        [ Character( CharacterTable( "U6(2)" ), [ 20736, 0, 384, 0, 0, 0, 54, 0, 0,
              0, 0, 48, 0, 16, 6, 0, 0, 0, 0, 0, 0, 6, 0, 2, 0, 0, 0, 4, 0, 0, 0, 0,
              1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ),
          Character( CharacterTable( "U6(2)" ), [ 20736, 0, 384, 0, 0, 0, 54, 0, 0,
              0, 48, 0, 0, 16, 6, 0, 0, 0, 0, 0, 0, 6, 0, 2, 0, 0, 4, 0, 0, 0, 0, 0,
              1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ),
          Character( CharacterTable( "U6(2)" ), [ 20736, 0, 384, 0, 0, 0, 54, 0, 0,
              48, 0, 0, 0, 16, 6, 0, 0, 0, 0, 0, 0, 6, 0, 2, 0, 4, 0, 0, 0, 0, 0, 0,
              1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ) ]
        gap> imgs:= Set( List( pi2, x -> Position( x, 48 ) ) );
        [ 10, 11, 12 ]
        gap> AtlasClassNames( t ){ imgs };
        [ "4C", "4D", "4E" ]
        gap> GetFusionMap( t, CharacterTable( "U6(2).3" ) ){ imgs };
        [ 10, 10, 10 ]
        gap> prim:= Concatenation( pi1, pi2 );;

Now statement (a) follows from the fact that the permutation characters have the value 1 on s.

        gap> spos:= Position( OrdersClassRepresentatives( t ), 11 );;
        gap> List( prim, x -> x[ spos ] );
        [ 1, 1, 1, 1 ]

For statement (b), we compute σ(S,s).

        gap> Maximum( ApproxP( prim, spos ) );
        5/21

Statement (c) follows from [CCN+85], plus the information that 3.U6(2) does not contain groups of the structure 3 ×M22.

        gap> PossibleClassFusions(
        >        CharacterTable( "Cyclic", 3 ) * CharacterTable( "M22" ),
        >        CharacterTable( "3.U6(2)" ) );
        [  ]

For statement (d), we need that the relevant maximal subgroups of S.2 are U5(2).2 and one subgroup M22.2, and that the relevant maximal subgroup of S.3 is U5(2) ×3, see [CCN+85,p. 115].

        gap> SigmaFromMaxes( CharacterTable( "U6(2).2" ), "11AB",
        >        [ CharacterTable( "U5(2).2" ), CharacterTable( "M22.2" ) ],
        >        [ 1, 1 ], "outer" );
        5/96
        gap> SigmaFromMaxes( CharacterTable( "U6(2).3" ), "11A",
        >        [ CharacterTable( "U5(2)" ) * CharacterTable( "Cyclic", 3 ) ],
        >        [ 1 ], "outer" );
        59/224

## 5 Computations using Groups

Before we start the computations using groups, we clean the workspace.

        gap> CleanWorkspace();

### 5.1 A2m+1, 2 ≤ m ≤ 11

For alternating groups of odd degree n = 2m+1, we choose s to be an n-cycle. The interesting cases in [BGK08,Proposition 6.7] are 5 ≤ n ≤ 23.
In each case, we compute representatives of the maximal subgroups of An, consider only those that contain an n-cycle, and then compute the permutation characters. Additionally, we show also the names that are used for the subgroups in the GAP Library of Transitive Groups, see [Hul05] and the documentation of this library in the GAP Reference Manual.

        gap> PrimitivesInfoForOddDegreeAlternatingGroup:= function( n )
        >     local G, max, cycle, spos, prim, nonz;
        >
        >     G:= AlternatingGroup( n );
        >
        >     # Compute representatives of the classes of maximal subgroups.
        >     max:= MaximalSubgroupClassReps( G );
        >
        >     # Omit subgroups that cannot contain an `n'-cycle.
        >     max:= Filtered( max, m -> IsTransitive( m, [ 1 .. n ] ) );
        >
        >     # Compute the permutation characters.
        >     cycle:= [];
        >     cycle[ n-1 ]:= 1;
        >     spos:= PositionProperty( ConjugacyClasses( CharacterTable( G ) ),
        >                c -> CycleStructurePerm( Representative( c ) ) = cycle );
        >     prim:= List( max, m -> TrivialCharacter( m )^G );
        >     nonz:= PositionsProperty( prim, x -> x[ spos ] <> 0 );
        >
        >     # Compute the subgroup names and the multiplicities.
        >     return rec( spos := spos,
        >                 prim := prim{ nonz },
        >                 grps := List( max{ nonz },
        >                               m -> TransitiveGroup( n,
        >                                        TransitiveIdentification( m ) ) ),
        >                 mult := List( prim{ nonz }, x -> x[ spos ] ) );
        > end;;

The sets M/ ∼ (s) and the values σ(An,s) are as follows. For each degree in question, the first list shows names for representatives of the conjugacy classes of maximal subgroups containing a fixed n-cycle, and the second list shows the number of conjugates in each class.

        gap> for n in [ 5, 7 .. 23 ] do
        >      prim:= PrimitivesInfoForOddDegreeAlternatingGroup( n );
        >      bound:= Maximum( ApproxP( prim.prim, prim.spos ) );
        >      Print( n, ": ", prim.grps, ", ", prim.mult, ", ", bound, "\n" );
        > od;
        5: [ D(5) = 5:2 ], [ 1 ], 1/3
        7: [ L(7) = L(3,2), L(7) = L(3,2) ], [ 1, 1 ], 2/5
        9: [ 1/2[S(3)^3]S(3), L(9):3=P|L(2,8) ], [ 1, 3 ], 9/35
        11: [ M(11), M(11) ], [ 1, 1 ], 2/105
        13: [ F_78(13)=13:6, L(13)=PSL(3,3), L(13)=PSL(3,3) ], [ 1, 2, 2 ], 4/1155
        15: [ 1/2[S(3)^5]S(5), 1/2[S(5)^3]S(3), L(15)=A_8(15)=PSL(4,2),
          L(15)=A_8(15)=PSL(4,2) ], [ 1, 1, 1, 1 ], 29/273
        17: [ L(17):4=PYL(2,16), L(17):4=PYL(2,16) ], [ 1, 1 ], 2/135135
        19: [ F_171(19)=19:9 ], [ 1 ], 1/6098892800
        21: [ t21n150, t21n161, t21n91 ], [ 1, 1, 2 ], 29/285
        23: [ M(23), M(23) ], [ 1, 1 ], 2/130945815

In the above output, a subgroup printed as `1/2[S(`n1`)^`n2`]S(`n2`)`, where n = n1 n2 holds, denotes the intersection of An with the wreath product Sn1 ≀ Sn2 ≤ Sn. (Note that the ATLAS denotes the subgroup `1/2[S(3)^3]S(3)` of A9 as 33:S4.) The groups printed as `P|L(2,8)` and `PYL(2,16)` denote PΓL(2,8) and PΓL(2,16), respectively. And the three subgroups of A21 have the structures (S3 ≀ S7) ∩A21, (S7 ≀ S3) ∩A21, and PGL(3,4), respectively.
Note that A9 contains two conjugacy classes of maximal subgroups of the type PΓL(2,8) ≅ L2(8):3, and that each 9-cycle in A9 is contained in exactly three conjugate subgroups of this type. For n ∈ { 13, 15, 17 }, An contains two conjugacy classes of isomorphic maximal subgroups of linear type, and each n-cycle is contained in subgroups from each class. Finally, A21 contains only one class of maximal subgroups of linear type.
For the two groups A5 and A7, the values computed above are not sufficient. See Section 5.2 and 5.4 for a further treatment.
The above computations look like a brute-force approach, but note that the computation of the maximal subgroups of alternating and symmetric groups in GAP uses the classification of these subgroups, and also the conjugacy classes of elements in alternating and symmetric groups can be computed cheaply.
Alternative (character-theoretic) computations for n ∈ { 5, 7, 9, 11, 13 } were shown in Section 4.3. (A hand calculation for the case n = 19 can be found in [BW75].)

### 5.2 A5

We show that S = A5 satisfies the following.

(a) σ(S) = 1/3, and this value is attained exactly for σ(S,s) with s of order 5.
(b) For s ∈ S of order 5, M(S,s) consists of one group of the type D10.
(c) P(S) = 1/3, and this value is attained exactly for P(S,s) with s of order 5.
(d) Each element in S together with one of (1,2)(3,4), (1,3)(2,4), (1,4)(2,3) generates a proper subgroup of S.
(e) Both the spread and the uniform spread of S is exactly two (see [BW75]), with s of order 5.

Statement (a) follows from inspection of the primitive permutation characters, cf. Section 4.3.

        gap> t:= CharacterTable( "A5" );;
        gap> ProbGenInfoSimple( t );
        [ "A5", 1/3, 2, [ "5A" ], [ 1 ] ]

Statement (b) can be read off from the primitive permutation characters, and the fact that the unique class of maximal subgroups that contain elements of order 5 consists of groups of the structure D10, see [CCN+85,p. 2].

        gap> OrdersClassRepresentatives( t );
        [ 1, 2, 3, 5, 5 ]
        gap> PrimitivePermutationCharacters( t );
        [ Character( CharacterTable( "A5" ), [ 5, 1, 2, 0, 0 ] ),
          Character( CharacterTable( "A5" ), [ 6, 2, 0, 1, 1 ] ),
          Character( CharacterTable( "A5" ), [ 10, 2, 1, 0, 0 ] ) ]

For statement (c), we compute that for all nonidentity elements s ∈ S and involutions g ∈ S, P(g,s) ≥ 1/3 holds, with equality if and only if s has order 5. We actually compute, for class representatives s, the proportion of involutions g such that 〈g, s 〉 ≠ S holds.

        gap> g:= AlternatingGroup( 5 );;
        gap> inv:= g.1^2 * g.2;
        (1,4)(2,5)
        gap> cclreps:= List( ConjugacyClasses( g ), Representative );;
        gap> SortParallel( List( cclreps, Order ), cclreps );
        gap> List( cclreps, Order );
        [ 1, 2, 3, 5, 5 ]
        gap> Size( ConjugacyClass( g, inv ) );
        15
        gap> prop:= List( cclreps,
        >                 r -> RatioOfNongenerationTransPermGroup( g, inv, r ) );
        [ 1, 1, 3/5, 1/3, 1/3 ]
        gap> Minimum( prop );
        1/3

Statement (d) follows by explicit computations.

        gap> triple:= [ (1,2)(3,4), (1,3)(2,4), (1,4)(2,3) ];;
        gap> CommonGeneratorWithGivenElements( g, cclreps, triple );
        fail

As for statement (e), we know from (a) that the uniform spread of S is at least two, and from (d) that the spread is less than three.

### 5.3 A6

We show that S = A6 satisfies the following.

(a) σ(S) = 2/3, and this value is attained exactly for σ(S,s) with s of order 5.
(b) For s of order 5, M(S,s) consists of two nonconjugate groups of the type A5.
(c) P(S) = 5/9, and this value is attained exactly for P(S,s) with s of order 5.
(d) Each element in S together with one of (1,2)(3,4), (1,3)(2,4), (1,4)(2,3) generates a proper subgroup of S.
(e) Both the spread and the uniform spread of S is exactly two (see [BW75]), with s of order 4.
(f) For x, y ∈ S6×, there is s ∈ S6 such that S ⊆ 〈x, s 〉∩〈y, s 〉. It is not possible to find s ∈ S with this property, or s in a prescribed conjugacy class of S6.
(g) σ( PGL(2,9) ) = 1/6 and σ( M10 ) = 1/9, with s of order 10 and 8, respectively.

(Note that in this example, the optimal choice of s for P(S) cannot be used to obtain the result on the exact spread.)
Statement (a) follows from inspection of the primitive permutation characters, cf. Section 4.3.

        gap> t:= CharacterTable( "A6" );;
        gap> ProbGenInfoSimple( t );
        [ "A6", 2/3, 1, [ "5A" ], [ 2 ] ]

Statement (b) can be read off from the permutation characters, and the fact that the two classes of maximal subgroups that contain elements of order 5 consist of groups of the structure A5, see [CCN+85,p. 4].

        gap> OrdersClassRepresentatives( t );
        [ 1, 2, 3, 3, 4, 5, 5 ]
        gap> prim:= PrimitivePermutationCharacters( t );
        [ Character( CharacterTable( "A6" ), [ 6, 2, 3, 0, 0, 1, 1 ] ),
          Character( CharacterTable( "A6" ), [ 6, 2, 0, 3, 0, 1, 1 ] ),
          Character( CharacterTable( "A6" ), [ 10, 2, 1, 1, 2, 0, 0 ] ),
          Character( CharacterTable( "A6" ), [ 15, 3, 3, 0, 1, 0, 0 ] ),
          Character( CharacterTable( "A6" ), [ 15, 3, 0, 3, 1, 0, 0 ] ) ]

For statement (c), we first compute that for all nonidentity elements s ∈ S and involutions g ∈ S, P(g,s) ≥ 5/9 holds, with equality if and only if s has order 5. We actually compute, for class representatives s, the proportion of involutions g such that 〈g, s 〉 ≠ S holds.

        gap> S:= AlternatingGroup( 6 );;
        gap> inv:= (S.1*S.2)^2;
        (1,3)(2,5)
        gap> cclreps:= List( ConjugacyClasses( S ), Representative );;
        gap> SortParallel( List( cclreps, Order ), cclreps );
        gap> List( cclreps, Order );
        [ 1, 2, 3, 3, 4, 5, 5 ]
        gap> C:= ConjugacyClass( S, inv );;
        gap> Size( C );
        45
        gap> prop:= List( cclreps,
        >                 r -> RatioOfNongenerationTransPermGroup( S, inv, r ) );
        [ 1, 1, 1, 1, 29/45, 5/9, 5/9 ]
        gap> Minimum( prop );
        5/9

Now statement (c) follows from the fact that for g ∈ S of order larger than two, σ(S,g) ≤ 1/2 < 5/9 holds.

        gap> ApproxP( prim, 6 );
        [ 0, 2/3, 1/2, 1/2, 0, 1/3, 1/3 ]

Statement (d) follows by explicit computations.

        gap> triple:= [ (1,2)(3,4), (1,3)(2,4), (1,4)(2,3) ];;
        gap> CommonGeneratorWithGivenElements( S, cclreps, triple );
        fail

An alternative triple to that in statement (d) is the one given in [BW75].

        gap> triple:= [ (1,3)(2,4), (1,5)(2,6), (3,6)(4,5) ];;
        gap> CommonGeneratorWithGivenElements( S, cclreps, triple );
        fail

Of course we can also construct such a triple, as follows.

        gap> TripleWithProperty( [ [ inv ], C, C ],
        >        l -> ForAll( S, elm ->
        >   ForAny( l, x -> not IsGeneratorsOfTransPermGroup( S, [ elm, x ] ) ) ) );
        [ (1,3)(2,5), (1,3)(2,6), (1,3)(2,4) ]

For statement (e), we use the random approach described in Section 3.3.

        gap> s:= (1,2,3,4)(5,6);;
        gap> reps:= Filtered( cclreps, x -> Order( x ) > 1 );;
        gap> ResetGlobalRandomNumberGenerators();
        gap> for pair in UnorderedTuples( reps, 2 ) do
        >      if RandomCheckUniformSpread( S, pair, s, 40 ) <> true then
        >        Print( "#E  nongeneration!\n" );
        >      fi;
        >    od;

We get no output, so a suitable element of order 4 works in all cases. Note that we cannot use an element of order 5, because it fixes a point in the natural permutation representation, and we may take x1 = (1,2,3) and x2 = (4,5,6). With this argument, only elements of order 4 and double 3-cycles are possible choices for s, and the latter are excluded by the fact that an outer automorphism maps the class of double s-cycles in A6 to the class of 3-cycles. So no element in A6 of order different from 4 works.
Next we show statement (f). Already in A6.21 = S6, elements s of order 4 do in general not work because they do not generate with transpositions.

        gap> G:= SymmetricGroup( 6 );;
        gap> RatioOfNongenerationTransPermGroup( G, s, (1,2) );
        1

Also, choosing s from a prescribed conjugacy class of S6 (that is, also s outside A6 is allowed) with the property that A6 ⊆ 〈x, s 〉∩〈y, s 〉 is not possible. Note that only 6-cycles are possible for s if x and y are commuting transpositions, and -applying the outer automorphism- no 6-cycle works for two commuting fixed-point free involutions. (The group is small enough for a brute force test.)

        gap> goods:= Filtered( Elements( G ),
        >      s -> IsGeneratorsOfTransPermGroup( G, [ s, (1,2) ] ) and
        >           IsGeneratorsOfTransPermGroup( G, [ s, (3,4) ] ) );;
        gap> Collected( List( goods, CycleStructurePerm ) );
        [ [ [ ,,,, 1 ], 24 ] ]
        gap> goods:= Filtered( Elements( G ),
        >      s -> IsGeneratorsOfTransPermGroup( G, [ s, (1,2)(3,4)(5,6) ] ) and
        >           IsGeneratorsOfTransPermGroup( G, [ s, (1,3)(2,4)(5,6) ] ) );;
        gap> Collected( List( goods, CycleStructurePerm ) );
        [ [ [ 1, 1 ], 24 ] ]

However, for each pair of nonidentity element x, y ∈ S6, there is s ∈ S6 such that 〈x, s 〉 and 〈y, s 〉 both contain A6. (If s works for the pair (x,y) then sg works for (xg,yg), so it is sufficient to consider only orbit representatives (x,y) under the conjugation action of G on pairs. Thus we check conjugacy class representatives x and, for fixed x, representatives of orbits of CG(x) on the classes yG, i. e., representatives of CG(y)-CG(x)-double cosets in G. Moreover, clearly we can restrict the checks to elements x, y of prime order.)

        gap> Sgens:= GeneratorsOfGroup( S );;
        gap> primord:= Filtered( List( ConjugacyClasses( G ), Representative ),
        >                        x -> IsPrimeInt( Order( x ) ) );;
        gap> for x in primord do
        >      for y in primord do
        >        for pair in DoubleCosetRepsAndSizes( G, Centralizer( G, y ),
        >                        Centralizer( G, x ) ) do
        >          if not ForAny( G, s -> IsSubset( Group( x,s ), S ) and
        >                                 IsSubset( Group( y^pair[1], s ), S ) ) then
        >            Error( [ x, y ] );
        >          fi;
        >        od;
        >      od;
        >    od;

In other words, the spread of S6 is 2 but the uniform spread of S6 is not 2 but only 1.
We cannot always find s ∈ A6 with the required property: If x is a transposition then any s with S ⊆ 〈x, s 〉 must be a 5-cycle.

        gap> filt:= Filtered( S, s -> IsSubset( Group( (1,2), s ), S ) );;
        gap> Collected( List( filt, Order ) );
        [ [ 5, 48 ] ]

Moreover, clearly such s fixes one of the moved points of x, so we may prescribe a transposition y ≠ x that commutes with x, it satisfies S ⊄ eq〈y, s 〉.
For the other two automorphic extensions A6.22 = PGL(2,9) and A6.23 = M10, we compute the character-theoretic bounds σ(A6.22) = 1/6 and σ(A6.23) = 1/9, which shows statement (g).

        gap> ProbGenInfoSimple( CharacterTable( "A6.2_2" ) );
        [ "A6.2_2", 1/6, 5, [ "10A" ], [ 1 ] ]
        gap> ProbGenInfoSimple( CharacterTable( "A6.2_3" ) );
        [ "A6.2_3", 1/9, 8, [ "8C" ], [ 1 ] ]

Note that σ′( PGL(2,9), s ) = 1/6, with s of order 5, and σ′( M10, s ) = 0 for any s ∈ A6 since M10 is a non-split extension of A6.

        gap> t:= CharacterTable( "A6" );;
        gap> t2:= CharacterTable( "A6.2_2" );;
        gap> spos:= PositionsProperty( OrdersClassRepresentatives( t ), x -> x = 5 );;
        gap> ProbGenInfoAlmostSimple( t, t2, spos );
        [ "A6.2_2", 1/6, [ "5A", "5B" ], [ 1, 1 ] ]

### 5.4 A7

We show that S = A7 satisfies the following.

(a) σ(S) = 2/5, and this value is attained exactly for σ(S,s) with s of order 7.
(b) For s of order 7, M(S,s) consists of two nonconjugate subgroups of the type L2(7).
(c) P(S) = 2/5, and this value is attained exactly for P(S,s) with s of order 7.
(d) The uniform spread of S is exactly three, with s of order 7.

Statement (a) follows from inspection of the primitive permutation characters, cf. Section 4.3.

        gap> t:= CharacterTable( "A7" );;
        gap> ProbGenInfoSimple( t );
        [ "A7", 2/5, 2, [ "7A" ], [ 2 ] ]

Statement (b) can be read off from the permutation characters, and the fact that the two classes of maximal subgroups that contain elements of order 7 consist of groups of the structure L2(7), see [CCN+85,p. 10].

        gap> OrdersClassRepresentatives( t );
        [ 1, 2, 3, 3, 4, 5, 6, 7, 7 ]
        gap> prim:= PrimitivePermutationCharacters( t );
        [ Character( CharacterTable( "A7" ), [ 7, 3, 4, 1, 1, 2, 0, 0, 0 ] ),
          Character( CharacterTable( "A7" ), [ 15, 3, 0, 3, 1, 0, 0, 1, 1 ] ),
          Character( CharacterTable( "A7" ), [ 15, 3, 0, 3, 1, 0, 0, 1, 1 ] ),
          Character( CharacterTable( "A7" ), [ 21, 5, 6, 0, 1, 1, 2, 0, 0 ] ),
          Character( CharacterTable( "A7" ), [ 35, 7, 5, 2, 1, 0, 1, 0, 0 ] ) ]

For statement (c), we compute that for all nonidentity elements s ∈ S and involutions g ∈ S, P(g,s) ≥ 2/5 holds, with equality if and only if s has order 7. We actually compute, for class representatives s, the proportion of involutions g such that 〈g, s 〉 ≠ S holds.

        gap> g:= AlternatingGroup( 7 );;
        gap> inv:= (g.1^3*g.2)^3;
        (2,6)(3,7)
        gap> ccl:= List( ConjugacyClasses( g ), Representative );;
        gap> SortParallel( List( ccl, Order ), ccl );
        gap> List( ccl, Order );
        [ 1, 2, 3, 3, 4, 5, 6, 7, 7 ]
        gap> Size( ConjugacyClass( g, inv ) );
        105
        gap> prop:= List( ccl, r -> RatioOfNongenerationTransPermGroup( g, inv, r ) );
        [ 1, 1, 1, 1, 89/105, 17/21, 19/35, 2/5, 2/5 ]
        gap> Minimum( prop );
        2/5

For statement (d), we use the random approach described in Section 3.3. By the character-theoretic bounds, it suffices to consider triples of elements in the classes `2A` or `3B`.

        gap> OrdersClassRepresentatives( t );
        [ 1, 2, 3, 3, 4, 5, 6, 7, 7 ]
        gap> spos:= Position( OrdersClassRepresentatives( t ), 7 );;
        gap> SizesCentralizers( t );
        [ 2520, 24, 36, 9, 4, 5, 12, 7, 7 ]
        gap> ApproxP( prim, spos );
        [ 0, 2/5, 0, 2/5, 2/15, 0, 0, 2/15, 2/15 ]
        gap> s:= (1,2,3,4,5,6,7);;
        gap> 3B:= (1,2,3)(4,5,6);;
        gap> C3B:= ConjugacyClass( g, 3B );;
        gap> Size( C3B );
        280
        gap> ResetGlobalRandomNumberGenerators();
        gap> for triple in UnorderedTuples( [ inv, 3B ], 3 ) do
        >      if RandomCheckUniformSpread( g, triple, s, 80 ) <> true then
        >        Print( "#E  nongeneration!\n" );
        >      fi;
        >    od;

We get no output, so the uniform spread of S is at least three.
Alternatively, we can use Lemma 2.1; this approach is technically more involved but faster. We work with the diagonal product of the two degree 15 representations of S, which is constructed from the information stored in the GAP Library of Tables of Marks.

        gap> tom:= TableOfMarks( "A7" );;
        gap> a7:= UnderlyingGroup( tom );;
        gap> tommaxes:= MaximalSubgroupsTom( tom );
        [ [ 39, 38, 37, 36, 35 ], [ 7, 15, 15, 21, 35 ] ]
        gap> index15:= List( tommaxes[1]{ [ 2, 3 ] },
        >                    i -> RepresentativeTom( tom, i ) );
        [ Group([ (1,3)(2,7), (1,5,7)(3,4,6) ]),
          Group([ (1,4)(2,3), (2,4,6)(3,5,7) ]) ]
        gap> deg15:= List( index15, s -> RightTransversal( a7, s ) );;
        gap> reps:= List( deg15, l -> Action( a7, l, OnRight ) );
        [ Group([ (1,5,7)(2,9,10)(3,11,4)(6,12,8)(13,14,15),
              (1,8,15,5,12)(2,13,11,3,10)(4,14,9,7,6) ]),
          Group([ (1,2,3)(4,6,5)(7,8,9)(10,12,11)(13,15,14),
              (1,12,3,13,10)(2,9,15,4,11)(5,6,14,7,8) ]) ]
        gap> g:= DiagonalProductOfPermGroups( reps );;
        gap> ResetGlobalRandomNumberGenerators();
        gap> repeat s:= Random( g );
        >    until Order( s ) = 7;
        gap> NrMovedPoints( s );
        28
        gap> mpg:= MovedPoints( g );;
        gap> fixs:= Difference( mpg, MovedPoints( s ) );;
        gap> orb_s:= Orbit( g, fixs, OnSets );;
        gap> Length( orb_s );
        120
        gap> SizesCentralizers( t );
        [ 2520, 24, 36, 9, 4, 5, 12, 7, 7 ]
        gap> repeat 2a:= Random( g ); until Order( 2a ) = 2;
        gap> repeat 3b:= Random( g );
        >    until Order( 3b ) = 3 and Size( Centralizer( g, 3b ) ) = 9;
        gap> orb2a:= Orbit( g, Difference( mpg, MovedPoints( 2a ) ), OnSets );;
        gap> orb3b:= Orbit( g, Difference( mpg, MovedPoints( 3b ) ), OnSets );;
        gap> orb2aor3b:= Union( orb2a, orb3b );;
        gap> TripleWithProperty( [ [ orb2a[1], orb3b[1] ], orb2aor3b, orb2aor3b ],
        >        l -> ForAll( orb_s,
        >                 f -> not IsEmpty( Intersection( Union( l ), f ) ) ) );
        fail

It remains to show that for any choice of s ∈ S, a quadruple of elements in S× exists such that s generates a proper subgroup of S together with at least one of these elements.
First we observe (without using GAP) that there is a pair of 3-cycles whose fixed points cover the seven points of the natural permutation representation. This implies the statement for all elements s ∈ S that fix a point in this representation. So it remains to consider elements s of the orders six and seven.
For the order seven element, the above setup and Lemma 2.1 can be used.

        gap> QuadrupleWithProperty( [ [ orb2a[1] ], orb2a, orb2a, orb2a ],
        >        l -> ForAll( orb_s,
        >                 f -> not IsEmpty( Intersection( Union( l ), f ) ) ) );
        [ [ 2, 11, 15, 19, 24, 29 ], [ 4, 9, 13, 21, 22, 28 ],
          [ 3, 10, 14, 20, 23, 30 ], [ 1, 5, 7, 25, 26, 27 ] ]

For the order six element, we use the diagonal product of the primitive permutation representations of the degrees 21 and 35.

        gap> has6A:= List( tommaxes[1]{ [ 4, 5 ] },
        >                  i -> RepresentativeTom( tom, i ) );
        [ Group([ (1,2)(3,7), (2,6,5,4)(3,7) ]),
          Group([ (2,3)(5,7), (1,2)(4,5,6,7), (2,3)(5,6) ]) ]
        gap> trans:= List( has6A, s -> RightTransversal( a7, s ) );;
        gap> reps:= List( trans, l -> Action( a7, l, OnRight ) );
        [ Group([ (1,16,12)(2,17,13)(3,18,11)(4,19,14)(15,20,21),
              (1,4,7,9,10)(2,5,8,3,6)(11,12,15,14,13)(16,20,19,17,18) ]),
          Group([ (2,16,6)(3,17,7)(4,18,8)(5,19,9)(10,20,26)(11,21,27)(12,22,28)(13,
                23,29)(14,24,30)(15,25,31), (1,2,3,4,5)(6,10,13,15,9)(7,11,14,8,
                12)(16,20,23,25,19)(17,21,24,18,22)(26,32,35,31,28)(27,33,29,34,30)
             ]) ]
        gap> g:= DiagonalProductOfPermGroups( reps );;
        gap> repeat s:= Random( g );
        >    until Order( s ) = 6;
        gap> NrMovedPoints( s );
        53
        gap> mpg:= MovedPoints( g );;
        gap> fixs:= Difference( mpg, MovedPoints( s ) );;
        gap> orb_s:= Orbit( g, fixs, OnSets );;
        gap> Length( orb_s );
        105
        gap> repeat 3a:= Random( g );
        >    until Order( 3a ) = 3 and Size( Centralizer( g, 3a ) ) = 36;
        gap> orb3a:= Orbit( g, Difference( mpg, MovedPoints( 3a ) ), OnSets );;
        gap> Length( orb3a );
        35
        gap> TripleWithProperty( [ [ orb3a[1] ], orb3a, orb3a ],
        >        l -> ForAll( orb_s,
        >                 f -> not IsEmpty( Intersection( Union( l ), f ) ) ) );
        [ [ 5, 7, 9, 17, 18, 19, 31, 32, 34, 40, 53 ],
          [ 5, 7, 9, 11, 13, 14, 30, 41, 42, 44, 53 ],
          [ 2, 3, 4, 5, 7, 9, 26, 47, 48, 50, 53 ] ]

So we have found not only a quadruple but even a triple of 3-cycles that excludes candidates s of order six.

### 5.5 Ld(q)

In the treatment of small dimensional linear groups S = SL(d,q), [BGK08] uses a Singer element s of order (qd−1)/(q−1). (So the order of the corresponding element in PSL(d,q) = (qd−1)/[(q−1) gcd(d,q−1)].) By [Ber00], M(S,s) consists of extension field type subgroups, except in the cases d = 2, q ∈ { 2, 5, 7, 9 }, and (d,q) = (3,4). These subgroups have the structure GL(d/p,qp):αq ∩S, for prime divisors p of d, where αq denotes the Frobenius automorphism that acts on matrices by raising each entry to the q-th power. (If q is a prime then we have GL(d/p,qp):αq = ΓL(d/p,qp).) Since s acts irreducibly, it is contained in at most one conjugate of each class of extension field type subgroups (cf. [BGK08,Lemma 2.12]).
First we write a GAP function `RelativeSigmaL` that takes a positive integer d and a basis B of the field extension of degree n over the field with q elements, and returns the group GL(d,qn):αq, as a subgroup of GL(dn,q).

        gap> RelativeSigmaL:= function( d, B )
        >     local n, F, q, glgens, diag, pi, frob, i;
        >
        >     n:= Length( B );
        >     F:= LeftActingDomain( UnderlyingLeftModule( B ) );
        >     q:= Size( F );
        >
        >     # Create the generating matrices inside the linear subgroup.
        >     glgens:= List( GeneratorsOfGroup( SL( d, q^n ) ),
        >                    m -> BlownUpMat( B, m ) );
        >
        >     # Create the matrix of a diagonal part that maps to determinant 1.
        >     diag:= IdentityMat( d*n, F );
        >     diag{ [ 1 .. n ] }{ [ 1 .. n ] }:= BlownUpMat( B, [ [ Z(q^n)^(q-1) ] ] );
        >     Add( glgens, diag );
        >
        >     # Create the matrix that realizes the Frobenius action,
        >     # and adjust the determinant.
        >     pi:= List( B, b -> Coefficients( B, b^q ) );
        >     frob:= NullMat( d*n, d*n, F );
        >     for i in [ 0 .. d-1 ] do
        >       frob{ [ 1 .. n ] + i*n }{ [ 1 .. n ] + i*n }:= pi;
        >     od;
        >     diag:= IdentityMat( d*n, F );
        >     diag{ [ 1 .. n ] }{ [ 1 .. n ] }:= BlownUpMat( B, [ [ Z(q^n) ] ] );
        >     diag:= diag^LogFFE( Inverse( Determinant( frob ) ), Determinant( diag ) );
        >
        >     # Return the result.
        >     return Group( Concatenation( glgens, [ diag * frob ] ) );
        > end;;

The next function computes σ(SL(d,q),s), by computing the sum of μ(g,S/(GL(d/p,qp):αq ∩S)), for prime divisors p of d, and taking the maximum over g ∈ S×. The computations take place in a permutation representation of PSL(d,q).

        gap> ApproxPForSL:= function( d, q )
        >     local G, epi, PG, primes, maxes, names, ccl;
        >
        >     # Check whether this is an admissible case (see [Be00]).
        >     if ( d = 2 and q in [ 2, 5, 7, 9 ] ) or ( d = 3 and q = 4 ) then
        >       return fail;
        >     fi;
        >
        >     # Create the group SL(d,q), and the map to PSL(d,q).
        >     G:= SL( d, q );
        >     epi:= ActionHomomorphism( G, NormedRowVectors( GF(q)^d ), OnLines );
        >     PG:= ImagesSource( epi );
        >
        >     # Create the subgroups corresponding to the prime divisors of `d'.
        >     primes:= Set( Factors( d ) );
        >     maxes:= List( primes, p -> RelativeSigmaL( d/p,
        >                                  Basis( AsField( GF(q), GF(q^p) ) ) ) );
        >     names:= List( primes, p -> Concatenation( "GL(", String( d/p ), ",",
        >                                  String( q^p ), ").", String( p ) ) );
        >     if 2 < q then
        >       names:= List( names, name -> Concatenation( name, " cap G" ) );
        >     fi;
        >
        >     # Compute the conjugacy classes of prime order elements in the maxes.
        >     # (In order to avoid computing all conjugacy classes of these subgroups,
        >     # we work in Sylow subgroups.)
        >     ccl:= List( List( maxes, x -> ImagesSet( epi, x ) ),
        >             M -> ClassesOfPrimeOrder( M, Set( Factors( Size( M ) ) ),
        >                                       TrivialSubgroup( M ) ) );
        >
        >     return [ names, UpperBoundFixedPointRatios( PG, ccl, true )[1] ];
        > end;;

We apply this function to the cases that are interesting in [BGK08,Section 5.12].

        gap> pairs:= [ [ 3, 2 ], [ 3, 3 ], [ 4, 2 ], [ 4, 3 ], [ 4, 4 ],
        >            [ 6, 2 ], [ 6, 3 ], [ 6, 4 ], [ 6, 5 ], [ 8, 2 ], [ 10, 2 ] ];;
        gap> array:= [];;
        gap> for pair in pairs do
        >      d:= pair[1];  q:= pair[2];
        >      approx:= ApproxPForSL( d, q );
        >      Add( array, [ Concatenation( "SL(", String(d), ",", String(q), ")" ),
        >                    (q^d-1)/(q-1),
        >                    approx[1], approx[2] ] );
        >    od;
        gap> PrintFormattedArray( array );
           SL(3,2)    7                             [ "GL(1,8).3" ]             1/4
           SL(3,3)   13                      [ "GL(1,27).3 cap G" ]            1/24
           SL(4,2)   15                             [ "GL(2,4).2" ]            3/14
           SL(4,3)   40                       [ "GL(2,9).2 cap G" ]         53/1053
           SL(4,4)   85                      [ "GL(2,16).2 cap G" ]           1/108
           SL(6,2)   63                [ "GL(3,4).2", "GL(2,8).3" ]       365/55552
           SL(6,3)  364   [ "GL(3,9).2 cap G", "GL(2,27).3 cap G" ] 22843/123845436
           SL(6,4) 1365  [ "GL(3,16).2 cap G", "GL(2,64).3 cap G" ]         1/85932
           SL(6,5) 3906 [ "GL(3,25).2 cap G", "GL(2,125).3 cap G" ]        1/484220
           SL(8,2)  255                             [ "GL(4,4).2" ]          1/7874
          SL(10,2) 1023               [ "GL(5,4).2", "GL(2,32).5" ]        1/129794

The only missing case for [BGK08] is S = L3(4), for which M(S,s) consists of three groups of the type L3(2) (see [CCN+85,p. 23]). The group L3(4) has been considered already in Section 4.3, where σ(S,s) = 1/5 has been proved. Also the cases SL(3,3), SL(4,2) ≅ A8, and SL(4,3) have been handled there.
An alternative character-theoretic proof for S = L6(2) looks as follows. In this case, the subgroups in M(S,s) have the types ΓL(3,4) ≅ GL(3,4).2 ≅ 3.L3(4).3.22 and ΓL(2,8) ≅ GL(2,8).3 ≅ (7 ×L2(8)).3.

        gap> t:= CharacterTable( "L6(2)" );;
        gap> s1:= CharacterTable( "3.L3(4).3.2_2" );;
        gap> s2:= CharacterTable( "(7xL2(8)).3" );;
        gap> SigmaFromMaxes( t, "63A", [ s1, s2 ], [ 1, 1 ] );
        365/55552

### 5.6 ∗ Ld(q) with prime d

For S = SL(d,q) with prime dimension d, and s ∈ S a Singer cycle, we have M(S,s) = { M }, where M = NS(〈s 〉) ≅ ΓL(1,qd) ∩S. So

σ(g,s) = μ(g,S/M) = |gS ∩M|/|gS| < |M|/|gS| ≤ (qd−1) ·d/|gS|

holds for any g ∈ S \Z(S), which implies σ( S, s ) < max{ (qd−1) ·d/|gS|; g ∈ S \Z(S) }. The right hand side of this inequality is returned by the following function. In [BGK08,Lemma 3.8], the global upper bound 1/qd is derived for primes d ≥ 5.

        gap> UpperBoundForSL:= function( d, q )
        >     local G, Msize, ccl;
        >
        >     if not IsPrimeInt( d ) then
        >       Error( "<d> must be a prime" );
        >     fi;
        >
        >     G:= SL( d, q );
        >     Msize:= (q^d-1) * d;
        >     ccl:= Filtered( ConjugacyClasses( G ),
        >                     c ->     Msize mod Order( Representative( c ) ) = 0
        >                          and Size( c ) <> 1 );
        >
        >     return Msize / Minimum( List( ccl, Size ) );
        > end;;

The interesting values are (d,q) with d ∈ { 5, 7, 11 } and q ∈ { 2, 3, 4 }, and perhaps also (d,q) ∈ { (3,2), (3,3) }. (Here we exclude SL(11,4) because writing down the conjugacy classes of this group would exceed the permitted memory.)

        gap> NrConjugacyClasses( SL(11,4) );
        1397660
        gap> pairs:= [ [ 3, 2 ], [ 3, 3 ], [ 5, 2 ], [ 5, 3 ], [ 5, 4 ],
        >              [ 7, 2 ], [ 7, 3 ], [ 7, 4 ],
        >              [ 11, 2 ], [ 11, 3 ] ];;
        gap> array:= [];;
        gap> for pair in pairs do
        >      d:= pair[1];  q:= pair[2];
        >      approx:= UpperBoundForSL( d, q );
        >      Add( array, [ Concatenation( "SL(", String(d), ",", String(q), ")" ),
        >                    (q^d-1)/(q-1),
        >                    approx ] );
        >    od;
        gap> PrintFormattedArray( array );
           SL(3,2)     7                                   7/8
           SL(3,3)    13                                   3/4
           SL(5,2)    31                              31/64512
           SL(5,3)   121                                 10/81
           SL(5,4)   341                                15/256
           SL(7,2)   127                             7/9142272
           SL(7,3)  1093                                14/729
           SL(7,4)  5461                               21/4096
          SL(11,2)  2047 2047/34112245508649716682268134604800
          SL(11,3) 88573                              22/59049

The exact values are clearly better than the above bounds. We compute them for L5(2) and L7(2). In the latter case, the class fusion of the 127:7 type subgroup M is not uniquely determined by the character tables; here we use the additional information that the elements of order 7 in M have centralizer order 49 in L7(2). (See Section 4.3 for the examples with d = 3.)

        gap> SigmaFromMaxes( CharacterTable( "L5(2)" ), "31A",
        >        [ CharacterTable( "31:5" ) ], [ 1 ] );
        1/5376
        gap> t:= CharacterTable( "L7(2)" );;
        gap> s:= CharacterTable( "P:Q", [ 127, 7 ] );;
        gap> pi:= PossiblePermutationCharacters( s, t );;
        gap> Length( pi );
        2
        gap> ord7:= PositionsProperty( OrdersClassRepresentatives( t ), x -> x = 7 );
        [ 38, 45, 76, 77, 83 ]
        gap> sizes:= SizesCentralizers( t ){ ord7 };
        [ 141120, 141120, 3528, 3528, 49 ]
        gap> List( pi, x -> x[83] );
        [ 42, 0 ]
        gap> spos:= Position( OrdersClassRepresentatives( t ), 127 );;
        gap> Maximum( ApproxP( pi{ [ 1 ] }, spos ) );
        1/4388290560

### 5.7 Automorphic Extensions of Ld(q)

For the following values of d and q, automorphic extensions G of Ld(q) had to be checked for [BGK08,Section 5.12].

(d,q) ∈ { (3,4), (6,2), (6,3), (6,4), (6,5), (10,2) }

The first case has been treated in Section 4.4. For the other cases, we compute σ′(G,s) below.
In any case, the extension by a graph automorphism occurs, which can be described by mapping each matrix in SL(d,q) to its inverse transpose. If q > 2, also extensions by diagonal automorphisms occur, which are induced by conjugation with elements in GL(d,q). If q is nonprime then also extensions by field automorphisms occur, which can be described by powering the matrix entries by roots of q. Finally, products (of prime order) of these three kinds of automorphisms have to be considered.
We start with the extension G of S = SL(d,q) by a graph automorphism. G can be embedded into GL(2d,q) by representing the matrix A ∈ S as a block diagonal matrix with diagonal blocks equal to A and A−tr, and representing the graph automorphism by a permutation matrix that interchanges the two blocks. In order to construct the field extension type subgroups of G, we have to choose the basis of the field extension in such a way that the subgroup is normalized by the permutation matrix; a sufficient condition is that the matrices of the Fq-linear mappings induced by the basis elements are symmetric.
(We do not give a function that computes a basis with this property from the parameters d and q. Instead, we only write down the bases that we will need.)

        gap> SymmetricBasis:= function( q, n )
        >     local vectors, B, issymmetric;
        >
        >     if   q = 2 and n = 2 then
        >       vectors:= [ Z(2)^0, Z(2^2) ];
        >     elif q = 2 and n = 3 then
        >       vectors:= [ Z(2)^0, Z(2^3), Z(2^3)^5 ];
        >     elif q = 2 and n = 5 then
        >       vectors:= [ Z(2)^0, Z(2^5), Z(2^5)^4, Z(2^5)^25, Z(2^5)^26 ];
        >     elif q = 3 and n = 2 then
        >       vectors:= [ Z(3)^0, Z(3^2) ];
        >     elif q = 3 and n = 3 then
        >       vectors:= [ Z(3)^0, Z(3^3)^2, Z(3^3)^7 ];
        >     elif q = 4 and n = 2 then
        >       vectors:= [ Z(2)^0, Z(2^4)^3 ];
        >     elif q = 4 and n = 3 then
        >       vectors:= [ Z(2)^0, Z(2^3), Z(2^3)^5 ];
        >     elif q = 5 and n = 2 then
        >       vectors:= [ Z(5)^0, Z(5^2)^2 ];
        >     elif q = 5 and n = 3 then
        >       vectors:= [ Z(5)^0, Z(5^3)^9, Z(5^3)^27 ];
        >     else
        >       Error( "sorry, no basis for <q> and <n> stored" );
        >     fi;
        >
        >     B:= Basis( AsField( GF(q), GF(q^n) ), vectors );
        >
        >     # Check that the basis really has the required property.
        >     issymmetric:= M -> M = TransposedMat( M );
        >     if not ForAll( B, b -> issymmetric( BlownUpMat( B, [ [ b ] ] ) ) ) then
        >       Error( "wrong basis!" );
        >     fi;
        >
        >     # Return the result.
        >     return B;
        > end;;

In later examples, we will need similar embeddings of matrices. Therefore, we provide a more general function `EmbeddedMatrix` that takes a field `F`, a matrix `mat`, and a function `func`, and returns a block diagonal matrix over `F` whose diagonal blocks are `mat` and `func( mat )`.

        gap> BindGlobal( "EmbeddedMatrix", function( F, mat, func )
        >   local d, result;
        >
        >   d:= Length( mat );
        >   result:= NullMat( 2*d, 2*d, F );
        >   result{ [ 1 .. d ] }{ [ 1 .. d ] }:= mat;
        >   result{ [ d+1 .. 2*d ] }{ [ d+1 .. 2*d ] }:= func( mat );
        >
        >   return result;
        > end );

The following function is similar to `ApproxPForSL`, the differences are that the group G in question is not SL(d,q) but the extension of this group by a graph automorphism, and that σ′(G,s) is computed not σ(G,s).

        gap> ApproxPForOuterClassesInExtensionOfSLByGraphAut:= function( d, q )
        >     local embedG, swap, G, orb, epi, PG, Gprime, primes, maxes, ccl, names;
        >
        >     # Check whether this is an admissible case (see [Be00],
        >     # note that a graph automorphism exists only for `d > 2').
        >     if d = 2 or ( d = 3 and q = 4 ) then
        >       return fail;
        >     fi;
        >
        >     # Provide a function that constructs a block diagonal matrix.
        >     embedG:= mat -> EmbeddedMatrix( GF( q ), mat,
        >                                     M -> TransposedMat( M^-1 ) );
        >
        >     # Create the matrix that exchanges the two blocks.
        >     swap:= NullMat( 2*d, 2*d, GF(q) );
        >     swap{ [ 1 .. d ] }{ [ d+1 .. 2*d ] }:= IdentityMat( d, GF(q) );
        >     swap{ [ d+1 .. 2*d ] }{ [ 1 .. d ] }:= IdentityMat( d, GF(q) );
        >
        >     # Create the group SL(d,q).2, and the map to the projective group.
        >     G:= ClosureGroupDefault( Group( List( GeneratorsOfGroup( SL( d, q ) ),
        >                                           embedG ) ),
        >                       swap );
        >     orb:= Orbit( G, One( G )[1], OnLines );
        >     epi:= ActionHomomorphism( G, orb, OnLines );
        >     PG:= ImagesSource( epi );
        >     Gprime:= DerivedSubgroup( PG );
        >
        >     # Create the subgroups corresponding to the prime divisors of `d'.
        >     primes:= Set( Factors( d ) );
        >     maxes:= List( primes,
        >               p -> ClosureGroupDefault( Group( List( GeneratorsOfGroup(
        >                          RelativeSigmaL( d/p, SymmetricBasis( q, p ) ) ),
        >                          embedG ) ),
        >                      swap ) );
        >
        >     # Compute conjugacy classes of outer involutions in the maxes.
        >     # (In order to avoid computing all conjugacy classes of these subgroups,
        >     # we work in the Sylow $2$ subgroups.)
        >     maxes:= List( maxes, M -> ImagesSet( epi, M ) );
        >     ccl:= List( maxes, M -> ClassesOfPrimeOrder( M, [ 2 ], Gprime ) );
        >     names:= List( primes, p -> Concatenation( "GL(", String( d/p ), ",",
        >                                    String( q^p ), ").", String( p ) ) );
        >
        >     return [ names, UpperBoundFixedPointRatios( PG, ccl, true )[1] ];
        > end;;

And these are the results for the groups we are interested in (and others).

        gap> ApproxPForOuterClassesInExtensionOfSLByGraphAut( 4, 3 );
        [ [ "GL(2,9).2" ], 17/117 ]
        gap> ApproxPForOuterClassesInExtensionOfSLByGraphAut( 4, 4 );
        [ [ "GL(2,16).2" ], 73/1008 ]
        gap> ApproxPForOuterClassesInExtensionOfSLByGraphAut( 6, 2 );
        [ [ "GL(3,4).2", "GL(2,8).3" ], 41/1984 ]
        gap> ApproxPForOuterClassesInExtensionOfSLByGraphAut( 6, 3 );
        [ [ "GL(3,9).2", "GL(2,27).3" ], 541/352836 ]
        gap> ApproxPForOuterClassesInExtensionOfSLByGraphAut( 6, 4 );
        [ [ "GL(3,16).2", "GL(2,64).3" ], 3265/12570624 ]
        gap> ApproxPForOuterClassesInExtensionOfSLByGraphAut( 6, 5 );
        [ [ "GL(3,25).2", "GL(2,125).3" ], 13001/195250000 ]
        gap> ApproxPForOuterClassesInExtensionOfSLByGraphAut( 8, 2 );
        [ [ "GL(4,4).2" ], 367/1007872 ]
        gap> ApproxPForOuterClassesInExtensionOfSLByGraphAut( 10, 2 );
        [ [ "GL(5,4).2", "GL(2,32).5" ], 609281/476346056704 ]

Now we consider diagonal automorphisms. We modify the approach for SL(d,q) by constructing the field extension type subgroups of GL(d,q) ...

        gap> RelativeGammaL:= function( d, B )
        >     local n, F, q, diag;
        >
        >     n:= Length( B );
        >     F:= LeftActingDomain( UnderlyingLeftModule( B ) );
        >     q:= Size( F );
        >     diag:= IdentityMat( d * n, F );
        >     diag{[ 1 .. n ]}{[ 1 .. n ]}:= BlownUpMat( B, [ [ Z(q^n) ] ] );
        >     return ClosureGroup( RelativeSigmaL( d, B ),  diag );
        > end;;

... and counting the elements of prime order outside the simple group.

        gap> ApproxPForOuterClassesInGL:= function( d, q )
        >     local G, epi, PG, Gprime, primes, maxes, names;
        >
        >     # Check whether this is an admissible case (see [Be00]).
        >     if ( d = 2 and q in [ 2, 5, 7, 9 ] ) or ( d = 3 and q = 4 ) then
        >       return fail;
        >     fi;
        >
        >     # Create the group GL(d,q), and the map to PGL(d,q).
        >     G:= GL( d, q );
        >     epi:= ActionHomomorphism( G, NormedRowVectors( GF(q)^d ), OnLines );
        >     PG:= ImagesSource( epi );
        >     Gprime:= ImagesSet( epi, SL( d, q ) );
        >
        >     # Create the subgroups corresponding to the prime divisors of `d'.
        >     primes:= Set( Factors( d ) );
        >     maxes:= List( primes, p -> RelativeGammaL( d/p,
        >                                    Basis( AsField( GF(q), GF(q^p) ) ) ) );
        >     maxes:= List( maxes, M -> ImagesSet( epi, M ) );
        >     names:= List( primes, p -> Concatenation( "M(", String( d/p ), ",",
        >                                    String( q^p ), ")" ) );
        >
        >     return [ names,
        >              UpperBoundFixedPointRatios( PG, List( maxes,
        >                  M -> ClassesOfPrimeOrder( M,
        >                           Set( Factors( Index( PG, Gprime ) ) ), Gprime ) ),
        >                  true )[1] ];
        > end;;

Here are the required results.

        gap> ApproxPForOuterClassesInGL( 6, 3 );
        [ [ "M(3,9)", "M(2,27)" ], 41/882090 ]
        gap> ApproxPForOuterClassesInGL( 4, 3 );
        [ [ "M(2,9)" ], 0 ]
        gap> ApproxPForOuterClassesInGL( 6, 4 );
        [ [ "M(3,16)", "M(2,64)" ], 1/87296 ]
        gap> ApproxPForOuterClassesInGL( 6, 5 );
        [ [ "M(3,25)", "M(2,125)" ], 821563/756593750000 ]

(Note that the extension field type subgroup in PGL(4,3) = L4(3).21 is a non-split extension of its intersection with L4(3), hence the zero value.)
Concerning extensions by Frobenius automorphisms, only the case (d,q) = (6,4) is interesting in [BGK08]. In fact, we would not need to compute anything for the extension G of S = SL(6,4) by the Frobenius map that squares each matrix entry. This is because M′(G,s) consists of the normalizers of the two subgroups of the types SL(3,16) and SL(2,64), and the former maximal subgroup is a non-split extension of its intersection with S, so only one maximal subgroup can contribute to σ′(G,s), which is thus smaller than 1/2, by [BGK08,Prop. 2.6].
However, it is easy enough to compute the exact value of σ′(G,s). We work with the projective action of S on its natural module, and compute the permutation induced by the Frobenius map as the Frobenius action on the normed row vectors.

        gap> matgrp:= SL(6,4);;
        gap> dom:= NormedRowVectors( GF(4)^6 );;
        gap> Gprime:= Action( matgrp, dom, OnLines );;
        gap> pi:= PermList( List( dom, v -> Position( dom, List( v, x -> x^2 ) ) ) );;
        gap> G:= ClosureGroup( Gprime, pi );;

Then we compute the maximal subgroups, the classes of outer involutions, and the bound, similar to the situation with graph automorphisms.

        gap> maxes:= List( [ 2, 3 ], p -> Normalizer( G,
        >              Action( RelativeSigmaL( 6/p,
        >                Basis( AsField( GF(4), GF(4^p) ) ) ), dom, OnLines ) ) );;
        gap> ccl:= List( maxes, M -> ClassesOfPrimeOrder( M, [ 2 ], Gprime ) );;
        gap> List( ccl, Length );
        [ 0, 1 ]
        gap> UpperBoundFixedPointRatios( G, ccl, true );
        [ 1/34467840, true ]

For (d,q) = (6,4), we have to consider also the extension G of S = SL(6,4) by the product α of the Frobenius map and the graph automorphism. We use the same approach as for the graph automorphism, i. e., we embed SL(6,4) into a 12-dimensional group of 6 ×6 block matrices, where the second block is the image of the first block under α, and describe α by the transposition of the two blocks.
First we construct the projective actions of S and G on an orbit of 1-spaces.

        gap> embedFG:= function( F, mat )
        >      return EmbeddedMatrix( F, mat,
        >                 M -> List( TransposedMat( M^-1 ),
        >                            row -> List( row, x -> x^2 ) ) );
        >    end;;
        gap> d:= 6;;  q:= 4;;
        gap> alpha:= NullMat( 2*d, 2*d, GF(q) );;
        gap> alpha{ [ 1 .. d ] }{ [ d+1 .. 2*d ] }:= IdentityMat( d, GF(q) );;
        gap> alpha{ [ d+1 .. 2*d ] }{ [ 1 .. d ] }:= IdentityMat( d, GF(q) );;
        gap> Gprime:= Group( List( GeneratorsOfGroup( SL(d,q) ),
        >                          mat -> embedFG( GF(q), mat ) ) );;
        gap> G:= ClosureGroupDefault( Gprime, alpha );;
        gap> orb:= Orbit( G, One( G )[1], OnLines );;
        gap> G:= Action( G, orb, OnLines );;
        gap> Gprime:= Action( Gprime, orb, OnLines );;

Next we construct the maximal subgroups, the classes of outer involutions, and the bound.

        gap> maxes:= List( Set( Factors( d ) ), p -> Group( List( GeneratorsOfGroup(
        >              RelativeSigmaL( d/p, Basis( AsField( GF(q), GF(q^p) ) ) ) ),
        >                mat -> embedFG( GF(q), mat ) ) ) );;
        gap> maxes:= List( maxes, x -> Action( x, orb, OnLines ) );;
        gap> maxes:= List( maxes, x -> Normalizer( G, x ) );;
        gap> ccl:= List( maxes, M -> ClassesOfPrimeOrder( M, [ 2 ], Gprime ) );;
        gap> List( ccl, Length );
        [ 0, 1 ]
        gap> UpperBoundFixedPointRatios( G, ccl, true );
        [ 1/10792960, true ]

The only missing cases are the extensions of SL(6,3) and SL(6,5) by the involutory outer automorphism that acts as the product of a diagonal and a graph automorphism.
In the case S = SL(6,3), we can directly write down the extension G.

        gap> d:= 6;;  q:= 3;;
        gap> diag:= IdentityMat( d, GF(q) );;
        gap> diag[1][1]:= Z(q);;
        gap> embedDG:= mat -> EmbeddedMatrix( GF(q), mat,
        >                                     M -> TransposedMat( M^-1 )^diag );;
        gap> Gprime:= Group( List( GeneratorsOfGroup( SL(d,q) ), embedDG ) );;
        gap> alpha:= NullMat( 2*d, 2*d, GF(q) );;
        gap> alpha{ [ 1 .. d ] }{ [ d+1 .. 2*d ] }:= IdentityMat( d, GF(q) );;
        gap> alpha{ [ d+1 .. 2*d ] }{ [ 1 .. d ] }:= IdentityMat( d, GF(q) );;
        gap> G:= ClosureGroupDefault( Gprime, alpha );;

The maximal subgroups are constructed as the normalizers in G of the extension field type subgroups in S. We work with a permutation representation of G.

        gap> maxes:= List( Set( Factors( d ) ), p -> Group( List( GeneratorsOfGroup(
        >              RelativeSigmaL( d/p, Basis( AsField( GF(q), GF(q^p) ) ) ) ),
        >                embedDG ) ) );;
        gap> orb:= Orbit( G, One( G )[1], OnLines );;
        gap> G:= Action( G, orb, OnLines );;
        gap> Gprime:= Action( Gprime, orb, OnLines );;
        gap> maxes:= List( maxes, M -> Normalizer( G, Action( M, orb, OnLines ) ) );;
        gap> ccl:= List( maxes, M -> ClassesOfPrimeOrder( M, [ 2 ], Gprime ) );;
        gap> List( ccl, Length );
        [ 1, 1 ]
        gap> UpperBoundFixedPointRatios( G, ccl, true );
        [ 25/352836, true ]

For S = SL(6,5), this approach does not work because we cannot realize the diagonal involution by an involutory matrix. Instead, we consider the extension of GL(6,5) ≅ 2.(2 ×L6(5)).2 by the graph automorphism α, which can be embedded into GL(12,5).

        gap> d:= 6;;  q:= 5;;
        gap> embedG:= mat -> EmbeddedMatrix( GF(q),
        >                                    mat, M -> TransposedMat( M^-1 ) );;
        gap> Gprime:= Group( List( GeneratorsOfGroup( SL(d,q) ), embedG ) );;
        gap> maxes:= List( Set( Factors( d ) ), p -> Group( List( GeneratorsOfGroup(
        >              RelativeSigmaL( d/p, Basis( AsField( GF(q), GF(q^p) ) ) ) ),
        >                embedG ) ) );;
        gap> diag:= IdentityMat( d, GF(q) );;
        gap> diag[1][1]:= Z(q);;
        gap> diag:= embedG( diag );;
        gap> alpha:= NullMat( 2*d, 2*d, GF(q) );;
        gap> alpha{ [ 1 .. d ] }{ [ d+1 .. 2*d ] }:= IdentityMat( d, GF(q) );;
        gap> alpha{ [ d+1 .. 2*d ] }{ [ 1 .. d ] }:= IdentityMat( d, GF(q) );;
        gap> G:= ClosureGroupDefault( Gprime, alpha * diag );;

Now we switch to the permutation action of this group on the 1-dimensional subspaces, thus factoring out the cyclic normal subgroup of order four. In this action, the involutory diagonal automorphism is represented by an involution, and we can proceed as above.

        gap> orb:= Orbit( G, One( G )[1], OnLines );;
        gap> Gprime:= Action( Gprime, orb, OnLines );;
        gap> G:= Action( G, orb, OnLines );;
        gap> maxes:= List( maxes, M -> Action( M, orb, OnLines ) );;
        gap> extmaxes:= List( maxes, M -> Normalizer( G, M ) );;
        gap> ccl:= List( extmaxes, M -> ClassesOfPrimeOrder( M, [ 2 ], Gprime ) );;
        gap> List( ccl, Length );
        [ 2, 1 ]
        gap> UpperBoundFixedPointRatios( G, ccl, true );
        [ 3863/6052750000, true ]

In the same way, we can recheck the values for the extensions of SL(6,5) by the diagonal or by the graph automorphism.

        gap> diag:= Permutation( diag, orb, OnLines );;
        gap> G:= ClosureGroupDefault( Gprime, diag );;
        gap> extmaxes:= List( maxes, M -> Normalizer( G, M ) );;
        gap> ccl:= List( extmaxes, M -> ClassesOfPrimeOrder( M, [ 2 ], Gprime ) );;
        gap> List( ccl, Length );
        [ 3, 1 ]
        gap> UpperBoundFixedPointRatios( G, ccl, true );
        [ 821563/756593750000, true ]
        gap> alpha:= Permutation( alpha, orb, OnLines );;
        gap> G:= ClosureGroupDefault( Gprime, alpha );;
        gap> extmaxes:= List( maxes, M -> Normalizer( G, M ) );;
        gap> ccl:= List( extmaxes, M -> ClassesOfPrimeOrder( M, [ 2 ], Gprime ) );;
        gap> List( ccl, Length );
        [ 2, 2 ]
        gap> UpperBoundFixedPointRatios( G, ccl, true );
        [ 13001/195250000, true ]

### 5.8 L3(2)

We show that S = L3(2) = SL(3,2) satisfies the following.

(a) σ(S) = 1/4, and this value is attained exactly for σ(S,s) with s of order 7.
(b) For s of order 7, M(S,s) consists of one group of the type 7:3.
(c) P(S) = 1/4, and this value is attained exactly for P(S,s) with s of order 7.
(d) The uniform spread of S is at exactly three, with s of order 7, and the spread of S is exactly four. (This had been left open in [BW75].)

(Note that in this example, the spread and the uniform spread differ.)
Statement (a) follows from inspection of the primitive permutation characters, cf. Section 4.3.

        gap> t:= CharacterTable( "L3(2)" );;
        gap> ProbGenInfoSimple( t );
        [ "L3(2)", 1/4, 3, [ "7A" ], [ 1 ] ]

Statement (b) can be read off from the permutation characters, and the fact that the unique class of maximal subgroups that contain elements of order 7 consists of groups of the structure 7:3, see [CCN+85,p. 3].

        gap> OrdersClassRepresentatives( t );
        [ 1, 2, 3, 4, 7, 7 ]
        gap> PrimitivePermutationCharacters( t );
        [ Character( CharacterTable( "L3(2)" ), [ 7, 3, 1, 1, 0, 0 ] ),
          Character( CharacterTable( "L3(2)" ), [ 7, 3, 1, 1, 0, 0 ] ),
          Character( CharacterTable( "L3(2)" ), [ 8, 0, 2, 0, 1, 1 ] ) ]

For the other statements, we will use the primitive permutation representations on 7 and 8 points of S (computed from the GAP Library of Tables of Marks), and their diagonal products of the degrees 14 and 15.

        gap> tom:= TableOfMarks( "L3(2)" );;
        gap> g:= UnderlyingGroup( tom );
        Group([ (2,4)(5,7), (1,2,3)(4,5,6) ])
        gap> mx:= MaximalSubgroupsTom( tom );
        [ [ 14, 13, 12 ], [ 7, 7, 8 ] ]
        gap> maxes:= List( mx[1], i -> RepresentativeTom( tom, i ) );;
        gap> tr:= List( maxes, s -> RightTransversal( g, s ) );;
        gap> acts:= List( tr, x -> Action( g, x, OnRight ) );;
        gap> g7:= acts[1];
        Group([ (3,4)(6,7), (1,3,2)(4,6,5) ])
        gap> g8:= acts[3];
        Group([ (1,6)(2,5)(3,8)(4,7), (1,7,3)(2,5,8) ])
        gap> g14:= DiagonalProductOfPermGroups( acts{ [ 1, 2 ] } );
        Group([ (3,4)(6,7)(11,13)(12,14), (1,3,2)(4,6,5)(8,11,9)(10,12,13) ])
        gap> g15:= DiagonalProductOfPermGroups( acts{ [ 2, 3 ] } );
        Group([ (4,6)(5,7)(8,13)(9,12)(10,15)(11,14),
          (1,4,2)(3,5,6)(8,14,10)(9,12,15) ])

First we compute that for all nonidentity elements s ∈ S and order three elements g ∈ S, P(g,s) ≥ 1/4 holds, with equality if and only if s has order 7; this implies statement (c). We actually compute, for class representatives s, the proportion of order three elements g such that 〈g, s 〉 ≠ S holds.

        gap> ccl:= List( ConjugacyClasses( g7 ), Representative );;
        gap> SortParallel( List( ccl, Order ), ccl );
        gap> List( ccl, Order );
        [ 1, 2, 3, 4, 7, 7 ]
        gap> Size( ConjugacyClass( g7, ccl[3] ) );
        56
        gap> prop:= List( ccl,
        >                 r -> RatioOfNongenerationTransPermGroup( g7, ccl[3], r ) );
        [ 1, 5/7, 19/28, 2/7, 1/4, 1/4 ]
        gap> Minimum( prop );
        1/4

Now we show that the uniform spread of S is less than four. In any of the primitive permutation representations of degree seven, we find three involutions whose sets of fixed points cover the seven points. The elements s of order different from 7 in S fix a point in this representation, so each such s generates a proper subgroup of S together with one of the three involutions.

        gap> x:= g7.1;
        (3,4)(6,7)
        gap> fix:= Difference( MovedPoints( g7 ), MovedPoints( x ) );
        [ 1, 2, 5 ]
        gap> orb:= Orbit( g7, fix, OnSets );
        [ [ 1, 2, 5 ], [ 1, 3, 4 ], [ 2, 3, 6 ], [ 2, 4, 7 ], [ 1, 6, 7 ],
          [ 3, 5, 7 ], [ 4, 5, 6 ] ]
        gap> Union( orb{ [ 1, 2, 5 ] } ) = [ 1 .. 7 ];
        true

So we still have to exclude elements s of order 7. In the primitive permutation representation of S on eight points, we find four elements of order three whose sets of fixed points cover the set of all points that are moved by S, so with each element of order seven in S, one of them generates an intransitive group.

        gap> three:= g8.2;
        (1,7,3)(2,5,8)
        gap> fix:= Difference( MovedPoints( g8 ), MovedPoints( three ) );
        [ 4, 6 ]
        gap> orb:= Orbit( g8, fix, OnSets );;
        gap> QuadrupleWithProperty( [ [ fix ], orb, orb, orb ],
        >        list -> Union( list ) = [ 1 .. 8 ] );
        [ [ 4, 6 ], [ 1, 7 ], [ 3, 8 ], [ 2, 5 ] ]

Together with statement (a), this proves that the uniform spread of S is exactly three, with s of order seven.
Each element of S fixes a point in the permutation representation on 15 points. So for proving that the spread of S is less than five, it is sufficient to find a quintuple of elements whose sets of fixed points cover all 15 points. (From the permutation characters it is clear that four of these elements must have order three, and the fifth must be an involution.)

        gap> x:= g15.1;
        (4,6)(5,7)(8,13)(9,12)(10,15)(11,14)
        gap> fixx:= Difference( MovedPoints( g15 ), MovedPoints( x ) );
        [ 1, 2, 3 ]
        gap> orbx:= Orbit( g15, fixx, OnSets );
        [ [ 1, 2, 3 ], [ 1, 4, 5 ], [ 1, 6, 7 ], [ 2, 4, 6 ], [ 3, 4, 7 ],
          [ 3, 5, 6 ], [ 2, 5, 7 ] ]
        gap> y:= g15.2;
        (1,4,2)(3,5,6)(8,14,10)(9,12,15)
        gap> fixy:= Difference( MovedPoints( g15 ), MovedPoints( y ) );
        [ 7, 11, 13 ]
        gap> orby:= Orbit( g15, fixy, OnSets );;
        gap> QuadrupleWithProperty( [ [ fixy ], orby, orby, orby ],
        >        l -> Difference( [ 1 .. 15 ], Union( l ) ) in orbx );
        [ [ 7, 11, 13 ], [ 5, 8, 14 ], [ 1, 10, 15 ], [ 3, 9, 12 ] ]

It remains to show that the spread of S is (at least) four. By the consideration of permutation characters, we know that we can find a suitable order seven element for all quadruples in question except perhaps quadruples of order three elements. We show that for each such case, we can choose s of order four. Since M(S,s) consists of two subgroups of the type S4, we work with the representation on 14 points.)
First we compute s and the S-orbit of its fixed points, and the S-orbit of the fixed points of an element x of order three. Then we prove that for each quadruple of conjugates of x, the union of their fixed points intersects the fixed points of at least one conjugate of s trivially.

        gap> ResetGlobalRandomNumberGenerators();
        gap> repeat s:= Random( g14 );
        >    until Order( s ) = 4;
        gap> s;
        (2,3,5,4)(6,7)(8,9)(11,12,14,13)
        gap> fixs:= Difference( MovedPoints( g14 ), MovedPoints( s ) );
        [ 1, 10 ]
        gap> orbs:= Orbit( g14, fixs, OnSets );;
        gap> Length( orbs );
        21
        gap> three:= g14.2;
        (1,3,2)(4,6,5)(8,11,9)(10,12,13)
        gap> fix:= Difference( MovedPoints( g14 ), MovedPoints( three ) );
        [ 7, 14 ]
        gap> orb:= Orbit( g14, fix, OnSets );;
        gap> Length( orb );
        28
        gap> QuadrupleWithProperty( [ [ fix ], orb, orb, orb ],
        >        l -> ForAll( orbs, o -> not IsEmpty( Intersection( o,
        >                        Union( l ) ) ) ) );
        fail

By Lemma 2.1, we are done.

### 5.9 M11

We show that S = M11 satisfies the following.

(a) σ(S) = 1/3, and this value is attained exactly for σ(S,s) with s of order 11.
(b) For s of order 11, M(S,s) consists of one group of the type L2(11).
(c) P(S) = 1/3, and this value is attained exactly for P(S,s) with s of order 11.
(d) Both the uniform spread and the spread of S is exactly three, with s of order 11.

Statement (a) follows from inspection of the primitive permutation characters, cf. Section 4.1.

        gap> t:= CharacterTable( "M11" );;
        gap> ProbGenInfoSimple( t );
        [ "M11", 1/3, 2, [ "11A" ], [ 1 ] ]

Statement (b) can be read off from the permutation characters, and the fact that the unique class of maximal subgroups that contain elements of order 11 consists of groups of the structure L2(11), see [CCN+85,p. 18].

        gap> OrdersClassRepresentatives( t );
        [ 1, 2, 3, 4, 5, 6, 8, 8, 11, 11 ]
        gap> PrimitivePermutationCharacters( t );
        [ Character( CharacterTable( "M11" ), [ 11, 3, 2, 3, 1, 0, 1, 1, 0, 0 ] ),
          Character( CharacterTable( "M11" ), [ 12, 4, 3, 0, 2, 1, 0, 0, 1, 1 ] ),
          Character( CharacterTable( "M11" ), [ 55, 7, 1, 3, 0, 1, 1, 1, 0, 0 ] ),
          Character( CharacterTable( "M11" ), [ 66, 10, 3, 2, 1, 1, 0, 0, 0, 0 ] ),
          Character( CharacterTable( "M11" ), [ 165, 13, 3, 1, 0, 1, 1, 1, 0, 0 ] ) ]
        gap> Maxes( t );
        [ "A6.2_3", "L2(11)", "3^2:Q8.2", "A5.2", "2.S4" ]

For the other statements, we will use the primitive permutation representations of S on 11 and 12 points (which are fetched from the ATLAS of Group Representations [WWT+]), and their diagonal product.

        gap> gens11:= OneAtlasGeneratingSet( "M11", NrMovedPoints, 11 );
        rec( charactername := "1a+10a",
          generators := [ (2,10)(4,11)(5,7)(8,9), (1,4,3,8)(2,5,6,9) ],
          groupname := "M11", id := "",
          identifier := [ "M11", [ "M11G1-p11B0.m1", "M11G1-p11B0.m2" ], 1, 11 ],
          isPrimitive := true, maxnr := 1, p := 11, rankAction := 2,
          repname := "M11G1-p11B0", repnr := 1, size := 7920, stabilizer := "A6.2_3",
          standardization := 1, transitivity := 4, type := "perm" )
        gap> g11:= GroupWithGenerators( gens11.generators );;
        gap> gens12:= OneAtlasGeneratingSet( "M11", NrMovedPoints, 12 );;
        gap> g12:= GroupWithGenerators( gens12.generators );;
        gap> g23:= DiagonalProductOfPermGroups( [ g11, g12 ] );
        Group([ (2,10)(4,11)(5,7)(8,9)(12,17)(13,20)(16,18)(19,21),
          (1,4,3,8)(2,5,6,9)(12,17,18,15)(13,19)(14,20)(16,22,23,21) ])

First we compute that for all nonidentity elements s ∈ S and involutions g ∈ S, P(g,s) ≥ 1/3 holds, with equality if and only if s has order 11; this implies statement (c). We actually compute, for class representatives s, the proportion of involutions g such that 〈g, s 〉 ≠ S holds.

        gap> inv:= g11.1;
        (2,10)(4,11)(5,7)(8,9)
        gap> ccl:= List( ConjugacyClasses( g11 ), Representative );;
        gap> SortParallel( List( ccl, Order ), ccl );
        gap> List( ccl, Order );
        [ 1, 2, 3, 4, 5, 6, 8, 8, 11, 11 ]
        gap> Size( ConjugacyClass( g11, inv ) );
        165
        gap> prop:= List( ccl,
        >                 r -> RatioOfNongenerationTransPermGroup( g11, inv, r ) );
        [ 1, 1, 1, 149/165, 25/33, 31/55, 23/55, 23/55, 1/3, 1/3 ]
        gap> Minimum( prop );
        1/3

For the first part of statement (d), we have to deal only with the case of triples of involutions.
The 11-cycle s is contained in exactly one maximal subgroup of S, of index 12. By Corollary 2.2, it is enough to show that in the primitive degree 12 representation of S, the fixed points of no triple (x1, x2, x3) of involutions in S can cover all twelve points; equivalenly (considering complements), we show that there is no triple such that the intersection of the sets of moved points is empty.

        gap> inv:= g12.1;
        (1,6)(2,9)(5,7)(8,10)
        gap> moved:= MovedPoints( inv );
        [ 1, 2, 5, 6, 7, 8, 9, 10 ]
        gap> orb12:= Orbit( g12, moved, OnSets );;
        gap> Length( orb12 );
        165
        gap> TripleWithProperty( [ orb12{[1]}, orb12, orb12 ],
        >        list -> IsEmpty( Intersection( list ) ) );
        fail

This implies that the uniform spread of S is at least three.
Now we show that there is a quadruple consisting of one element of order three and three involutions whose fixed points cover all points in the degree 23 representation constructed above; since the permutation character of this representation is strictly positive, this implies that S does not have spread four, by Corollary 2.3, and we have proved statement (d).

        gap> inv:= g23.1;
        (2,10)(4,11)(5,7)(8,9)(12,17)(13,20)(16,18)(19,21)
        gap> moved:= MovedPoints( inv );
        [ 2, 4, 5, 7, 8, 9, 10, 11, 12, 13, 16, 17, 18, 19, 20, 21 ]
        gap> orb23:= Orbit( g23, moved, OnSets );;
        gap> three:= ( g23.1*g23.2^2 )^2;
        (2,6,10)(4,8,7)(5,9,11)(12,17,23)(15,18,16)(19,21,22)
        gap> movedthree:= MovedPoints( three );;
        gap> QuadrupleWithProperty( [ [ movedthree ], orb23, orb23, orb23 ],
        >        list -> IsEmpty( Intersection( list ) ) );
        [ [ 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15, 16, 17, 18, 19, 21, 22, 23 ],
          [ 1, 3, 4, 5, 6, 8, 9, 10, 12, 13, 14, 16, 17, 18, 20, 21 ],
          [ 1, 2, 3, 4, 5, 6, 7, 11, 12, 13, 14, 15, 18, 19, 20, 23 ],
          [ 1, 2, 3, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 20, 22, 23 ] ]

### 5.10 M12

We show that S = M12 satisfies the following.

(a) σ(S) = 1/3, and this value is attained exactly for σ(S,s) with s of order 10.
(b) For s ∈ S of order 10, M(S,s) consists of two nonconjugate subgroups of the type A6.22, and one group of the type 2 ×S5.
(c) P(S) = 31/99, and this value is attained exactly for P(S,s) with s of order 10.
(d) The uniform spread of S is at least three, with s of order 10.
(e) σ′(Aut(S), s) = 4/99.

Statement (a) follows from inspection of the primitive permutation characters, cf. Section 4.1.

        gap> t:= CharacterTable( "M12" );;
        gap> ProbGenInfoSimple( t );
        [ "M12", 1/3, 2, [ "10A" ], [ 3 ] ]

Statement (b) can be read off from the permutation characters, and the fact that the only classes of maximal subgroups that contain elements of order 10 consist of groups of the structures A6.22 (two classes) and 2 ×S5 (one class), see [CCN+85,p. 33].

        gap> spos:= Position( OrdersClassRepresentatives( t ), 10 );
        13
        gap> prim:= PrimitivePermutationCharacters( t );;
        gap> List( prim, x -> x{ [ 1, spos ] } );
        [ [ 12, 0 ], [ 12, 0 ], [ 66, 1 ], [ 66, 1 ], [ 144, 0 ], [ 220, 0 ],
          [ 220, 0 ], [ 396, 1 ], [ 495, 0 ], [ 495, 0 ], [ 1320, 0 ] ]
        gap> Maxes( t );
        [ "M11", "M12M2", "A6.2^2", "M12M4", "L2(11)", "3^2.2.S4", "M12M7", "2xS5",
          "M8.S4", "4^2:D12", "A4xS3" ]

For statement (c) (which implies statement (d)), we use the primitive permutation representation on 12 points.

        gap> g:= MathieuGroup( 12 );
        Group([ (1,2,3,4,5,6,7,8,9,10,11), (3,7,11,8)(4,10,5,6),
          (1,12)(2,11)(3,6)(4,8)(5,9)(7,10) ])

First we show that for s of order 10, P(S,s) = 31/99 holds.

        gap> approx:= ApproxP( prim, spos );
        [ 0, 3/11, 1/3, 1/11, 1/132, 13/99, 13/99, 13/396, 1/132, 1/33, 1/33, 1/33,
          13/396, 0, 0 ]
        gap> 2B:= g.2^2;
        (3,11)(4,5)(6,10)(7,8)
        gap> Size( ConjugacyClass( g, 2B ) );
        495
        gap> ResetGlobalRandomNumberGenerators();
        gap> repeat s:= Random( g );
        >    until Order( s ) = 10;
        gap> prop:= RatioOfNongenerationTransPermGroup( g, 2B, s );
        31/99
        gap> Filtered( approx, x -> x >= prop );
        [ 1/3 ]

Next we show that for s of order different from 10, P(g,s) is larger than 31/99 for suitable g ∈ S×. Except for s in the class `6A` (which fixes no point in the degree 12 representation), it suffices to consider g in the class `2B` (with four fixed points).

        gap> x:= g.2^2;
        (3,11)(4,5)(6,10)(7,8)
        gap> ccl:= List( ConjugacyClasses( g ), Representative );;
        gap> SortParallel( List( ccl, Order ), ccl );
        gap> prop:= List( ccl, r -> RatioOfNongenerationTransPermGroup( g, x, r ) );
        [ 1, 1, 1, 1, 39/55, 1, 1, 29/33, 7/55, 43/55, 383/495, 383/495, 31/99, 5/9,
          5/9 ]
        gap> bad:= Filtered( prop, x -> x < 31/99 );
        [ 7/55 ]
        gap> pos:= Position( prop, bad[1] );;
        gap> [ Order( ccl[ pos ] ), NrMovedPoints( ccl[ pos ] ) ];
        [ 6, 12 ]

In the remaining case, we choose g in the class `2A` (which is fixed point free).

        gap> x:= g.3;
        (1,12)(2,11)(3,6)(4,8)(5,9)(7,10)
        gap> s:= ccl[ pos ];;
        gap> prop:= RatioOfNongenerationTransPermGroup( g, x, s );
        17/33
        gap> prop > 31/99;
        true

Statement (e) has been shown already in Section 4.2.

### 5.11 O7(3)

We show that S = O7(3) satisfies the following.

(a) σ(S) = 199/351, and this value is attained exactly for σ(S,s) with s of order 14.
(b) For s ∈ S of order 14, M(S,s) consists of one group of the type 2.U4(3).22 = Ω−(6,3).2 and two nonconjugate groups of the type S9.
(c) P(S) = 155/351, and this value is attained exactly for P(S,s) with s of order 14.
(d) The uniform spread of S is at least three, with s of order 14.
(e) σ′(Aut(S), s) = 1/3.

Currently GAP provides neither the table of marks of S nor all character tables of its maximal subgroups. First we compute those primitive permutation characters of S that have the degrees 351 (point stabilizer 2.U4(3).22), 364 (point stabilizer 35:U4(2).2), 378 (point stabilizer L4(3).22), 1 080 (point stabilizer G2(3), two classes), 1 120 (point stabilizer 33+3:L3(3)), 3 159 (point stabilizer S6(2), two classes), 12 636 (point stabilizer S9, two classes), 22 113 (point stabilizer (22 ×U4(2)).2, which extends to D8 ×U4(2).2 in O7(3).2), and 28 431 (point stabilizer 26:A7).
(So we ignore the primitive permutation characters of the degrees 3 640, 265 356, and 331 695. Note that the orders of the corresponding subgroups are not divisible by 7.)

        gap> t:= CharacterTable( "O7(3)" );;
        gap> someprim:= [];;
        gap> pi:= PossiblePermutationCharacters(
        >             CharacterTable( "2.U4(3).2_2" ), t );;  Length( pi );
        1
        gap> Append( someprim, pi );
        gap> pi:= PermChars( t, rec( torso:= [ 364 ] ) );;  Length( pi );
        1
        gap> Append( someprim, pi );
        gap> pi:= PossiblePermutationCharacters(
        >             CharacterTable( "L4(3).2_2" ), t );;  Length( pi );
        1
        gap> Append( someprim, pi );
        gap> pi:= PossiblePermutationCharacters( CharacterTable( "G2(3)" ), t );
        [ Character( CharacterTable( "O7(3)" ), [ 1080, 0, 0, 24, 108, 0, 0, 0, 27,
              18, 9, 0, 12, 4, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 3, 6, 0, 3,
              2, 2, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 4, 0, 3, 0, 1, 1, 0, 0, 0, 0, 0,
              0, 0 ] ), Character( CharacterTable( "O7(3)" ),
            [ 1080, 0, 0, 24, 108, 0, 0, 27, 0, 18, 9, 0, 12, 4, 0, 0, 0, 0, 0, 0, 0,
              0, 12, 0, 0, 0, 0, 3, 0, 0, 6, 3, 2, 2, 2, 0, 0, 3, 0, 0, 0, 0, 0, 0,
              0, 4, 3, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0 ] ) ]
        gap> Append( someprim, pi );
        gap> pi:= PermChars( t, rec( torso:= [ 1120 ] ) );;  Length( pi );
        1
        gap> Append( someprim, pi );
        gap> pi:= PossiblePermutationCharacters( CharacterTable( "S6(2)" ), t );
        [ Character( CharacterTable( "O7(3)" ), [ 3159, 567, 135, 39, 0, 81, 0, 0,
              27, 27, 0, 15, 3, 3, 7, 4, 0, 27, 0, 0, 0, 0, 0, 9, 3, 0, 9, 0, 3, 9,
              3, 0, 2, 1, 1, 0, 0, 0, 3, 0, 2, 0, 0, 0, 3, 0, 0, 3, 1, 0, 0, 0, 1, 0,
              0, 0, 0, 0 ] ), Character( CharacterTable( "O7(3)" ),
            [ 3159, 567, 135, 39, 0, 81, 0, 27, 0, 27, 0, 15, 3, 3, 7, 4, 0, 27, 0,
              0, 0, 0, 0, 9, 3, 0, 9, 3, 0, 3, 9, 0, 2, 1, 1, 0, 0, 3, 0, 0, 2, 0, 0,
              0, 3, 0, 3, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 ] ) ]
        gap> Append( someprim, pi );
        gap> pi:= PossiblePermutationCharacters( CharacterTable( "S9" ), t );
        [ Character( CharacterTable( "O7(3)" ), [ 12636, 1296, 216, 84, 0, 81, 0, 0,
              108, 27, 0, 6, 0, 12, 10, 1, 0, 27, 0, 0, 0, 0, 0, 9, 3, 0, 9, 0, 12,
              9, 3, 0, 1, 0, 2, 0, 0, 0, 3, 1, 1, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 1, 1,
              0, 0, 0, 0, 1 ] ), Character( CharacterTable( "O7(3)" ),
            [ 12636, 1296, 216, 84, 0, 81, 0, 108, 0, 27, 0, 6, 0, 12, 10, 1, 0, 27,
              0, 0, 0, 0, 0, 9, 3, 0, 9, 12, 0, 3, 9, 0, 1, 0, 2, 0, 0, 3, 0, 1, 1,
              0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1 ] ) ]
        gap> Append( someprim, pi );
        gap> t2:= CharacterTable( "O7(3).2" );;
        gap> s2:= CharacterTable( "Dihedral", 8 ) * CharacterTable( "U4(2).2" );
        CharacterTable( "Dihedral(8)xU4(2).2" )
        gap> pi:= PossiblePermutationCharacters( s2, t2 );;  Length( pi );
        1
        gap> pi:= RestrictedClassFunctions( pi, t );;
        gap> Append( someprim, pi );
        gap> pi:= PossiblePermutationCharacters(
        >             CharacterTable( "2^6:A7" ), t );;  Length( pi );
        1
        gap> Append( someprim, pi );
        gap> List( someprim, x -> x[1] );
        [ 351, 364, 378, 1080, 1080, 1120, 3159, 3159, 12636, 12636, 22113, 28431 ]

Note that in the three cases where two possible permutation characters were found, there are in fact two classes of subgroups that induce different permutation characters. For the subgroups of the types G2(3) and S6(2), this is stated in [CCN+85,p. 109], and for the subgroups of the type S9, this follows from the fact that each S9 type subgroup in S contains elements in exactly one of the classes `3D` or `3E`, and these two classes are fused by the outer automorphism of S.

        gap> cl:= PositionsProperty( AtlasClassNames( t ),
        >                            x -> x in [ "3D", "3E" ] );
        [ 8, 9 ]
        gap> List( Filtered( someprim, x -> x[1] = 12636 ), pi -> pi{ cl } );
        [ [ 0, 108 ], [ 108, 0 ] ]
        gap> GetFusionMap( t, t2 ){ cl };
        [ 8, 8 ]

Now we compute the lower bounds for σ( S, s′ ) that are given by the sublist `someprim` of the primitive permutation characters.

        gap> spos:= Position( OrdersClassRepresentatives( t ), 14 );
        52
        gap> Maximum( ApproxP( someprim, spos ) );
        199/351

This shows that σ( S, s ) = 199/351 holds. For statement (a), we have to show that choosing s′ from another class than `14A` yields a larger value for σ( S, s′ ).

        gap> approx:= List( [ 1 .. NrConjugacyClasses( t ) ],
        >       i -> Maximum( ApproxP( someprim, i ) ) );;
        gap> PositionsProperty( approx, x -> x <= 199/351 );
        [ 52 ]

Statement (b) can be read off from the permutation characters.

        gap> pos:= PositionsProperty( someprim, x -> x[ spos ] <> 0 );
        [ 1, 9, 10 ]
        gap> List( someprim{ pos }, x -> x{ [ 1, spos ] } );
        [ [ 351, 1 ], [ 12636, 1 ], [ 12636, 1 ] ]

For statement (c), we first compute P(g, s) for g in the class `2A`, via explicit computations with the group. For dealing with this case, we first construct a faithful permutation representation of O7(3) from the natural matrix representation of SO(7,3).

        gap> so73:= SpecialOrthogonalGroup( 7, 3 );;
        gap> o73:= DerivedSubgroup( so73 );;
        gap> orbs:= Orbits( o73, Elements( GF(3)^7 ) );;
        gap> Set( List( orbs, Length ) );
        [ 1, 702, 728, 756 ]
        gap> g:= Action( o73, First( orbs, x -> Length( x ) = 702 ) );;
        gap> Size( g ) = Size( t );
        true

A `2A` element g can be found as the 7-th power of any element of order 14 in S.

        gap> ResetGlobalRandomNumberGenerators();
        gap> repeat s:= Random( g );
        >    until Order( s ) = 14;
        gap> 2A:= s^7;;
        gap> bad:= RatioOfNongenerationTransPermGroup( g, 2A, s );
        155/351
        gap> bad > 1/3;
        true
        gap> approx:= ApproxP( someprim, spos );;
        gap> PositionsProperty( approx, x -> x >= 1/3 );
        [ 2 ]

This shows that P(g,s) = 155/351 > 1/3. Since σ( g, s ) < 1/3 for all nonidentity g not in the class `2A`, we have P( S, s ) = 155/351. For statement (c), it remains to show that P( S, s′ ) is larger than 155/351 whenever s′ is not of order 14. First we compute P( g, s′ ), for g in the class `2A`.

        gap> consider:= RepresentativesMaximallyCyclicSubgroups( t );
        [ 18, 19, 25, 26, 27, 30, 31, 32, 34, 35, 38, 39, 41, 42, 43, 44, 45, 46, 47,
          48, 49, 50, 52, 53, 54, 56, 57, 58 ]
        gap> Length( consider );
        28
        gap> consider:= ClassesPerhapsCorrespondingToTableColumns( g, t, consider );;
        gap> Length( consider );
        31
        gap> consider:= List( consider, Representative );;
        gap> SortParallel( List( consider, Order ), consider );
        gap> app2A:= List( consider, c ->
        >       RatioOfNongenerationTransPermGroup( g, 2A, c ) );
        [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 85/117, 1, 10/13, 10/13, 1, 1, 23/39, 23/39, 1,
          1, 1, 1, 1, 1/3, 1/3, 155/351, 67/117, 1, 1, 1, 1, 191/351 ]
        gap> test:= PositionsProperty( app2A, x -> x <= 155/351 );
        [ 23, 24, 25 ]
        gap> List( test, i -> Order( consider[i] ) );
        [ 13, 13, 14 ]

We see that only for s′ in one of the two (algebraically conjugate) classes of element order 13, P( S, s′ ) has a chance to be smaller than 155/351. This possibility is now excluded by counting elements in the class `3A` that do not generate S together with s′ of order 13.

        gap> C3A:= First( ConjugacyClasses( g ),
        >               c -> Order( Representative( c ) ) = 3 and Size( c ) = 7280 );;
        gap> repeat ss:= Random( g );
        >    until Order( ss ) = 13;
        gap> bad:= RatioOfNongenerationTransPermGroup( g, Representative( C3A ), ss );
        17/35
        gap> bad > 155/351;
        true

Now we show statement (d): For each triple (x1, x2, x3) of nonidentity elements in S, there is an element s in the class `14A` such that 〈xi, s 〉 = S holds for 1 ≤ i ≤ 3. We can read off from the character-theoretic data that only those triples have to be checked for which at least two elements are contained in the class `2A`, and the third element lies in one of the classes `2A`, `2B`, `3B`.

        gap> approx:= ApproxP( someprim, spos );;
        gap> max:= Maximum( approx{ [ 3 .. Length( approx ) ] } );
        59/351
        gap> 155 + 2*59 < 351;
        true
        gap> third:= PositionsProperty( approx, x -> 2 * 155/351 + x >= 1 );
        [ 2, 3, 6 ]
        gap> ClassNames( t ){ third };
        [ "2a", "2b", "3b" ]

We can find elements in the classes `2B` and `3B` as powers of arbitrary elements of the orders 20 and 15, respectively.

        gap> ord20:= PositionsProperty( OrdersClassRepresentatives( t ),
        >                               x -> x = 20 );
        [ 58 ]
        gap> PowerMap( t, 10 ){ ord20 };
        [ 3 ]
        gap> repeat x:= Random( g );
        >    until Order( x ) = 20;
        gap> 2B:= x^10;;
        gap> C2B:= ConjugacyClass( g, 2B );;
        gap> ord15:= PositionsProperty( OrdersClassRepresentatives( t ),
        >                               x -> x = 15 );
        [ 53 ]
        gap> PowerMap( t, 10 ){ ord15 };
        [ 6 ]
        gap> repeat x:= Random( g );
        >    until Order( x ) = 15;
        gap> 3B:= x^5;;
        gap> C3B:= ConjugacyClass( g, 3B );;

The existence of s can be shown with the random approach described in Section 3.3.

        gap> repeat s:= Random( g );
        >    until Order( s ) = 14;
        gap> RandomCheckUniformSpread( g, [ 2A, 2A, 2A ], s, 50 );
        true
        gap> RandomCheckUniformSpread( g, [ 2B, 2A, 2A ], s, 50 );
        true
        gap> RandomCheckUniformSpread( g, [ 3B, 2A, 2A ], s, 50 );
        true

Finally, we show statement (e). Let G = Aut(S) = S.2. By [CCN+85,p. 109], M′(G,s) consists of the extension of the 2.U4(3).21 type subgroup. We compute the extension of the permutation character.

        gap> prim:= someprim{ [ 1 ] };
        [ Character( CharacterTable( "O7(3)" ), [ 351, 127, 47, 15, 27, 45, 36, 0, 0,
              9, 0, 15, 3, 3, 7, 6, 19, 19, 10, 11, 12, 8, 3, 5, 3, 6, 1, 0, 0, 3, 3,
              0, 1, 1, 1, 6, 3, 0, 0, 2, 2, 0, 3, 0, 3, 3, 0, 0, 1, 0, 0, 1, 0, 4, 4,
              1, 2, 0 ] ) ]
        gap> spos:= Position( AtlasClassNames( t ), "14A" );;
        gap> t2:= CharacterTable( "O7(3).2" );;
        gap> map:= InverseMap( GetFusionMap( t, t2 ) );;
        gap> torso:= List( prim, pi -> CompositionMaps( pi, map ) );;
        gap> ext:= List( torso, x -> PermChars( t2, rec( torso:= x ) ) );
        [ [ Character( CharacterTable( "O7(3).2" ), [ 351, 127, 47, 15, 27, 45, 36,
                  0, 9, 0, 15, 3, 3, 7, 6, 19, 19, 10, 11, 12, 8, 3, 5, 3, 6, 1, 0,
                  3, 0, 1, 1, 1, 6, 3, 0, 2, 2, 0, 3, 0, 3, 3, 0, 1, 0, 0, 1, 0, 4,
                  1, 2, 0, 117, 37, 21, 45, 1, 13, 5, 1, 9, 9, 18, 15, 1, 7, 9, 6, 4,
                  0, 3, 0, 3, 3, 6, 2, 2, 9, 6, 1, 3, 1, 4, 1, 2, 1, 1, 0, 3, 1, 0,
                  0, 0, 0, 1, 1, 0, 0 ] ) ] ]
        gap> approx:= ApproxP( Concatenation( ext ),
        >        Position( AtlasClassNames( t2 ), "14A" ) );;
        gap> Maximum( approx{ Difference(
        >      PositionsProperty( OrdersClassRepresentatives( t2 ), IsPrimeInt ),
        >      ClassPositionsOfDerivedSubgroup( t2 ) ) } );
        1/3

### 5.12 O8+(2)

We show that S = O8+(2) = Ω+(8,2) satisfies the following.

(a) σ(S) = 334/315, and this value is attained exactly for σ(S,s) with s of order 15.
(b) For s ∈ S of order 15, M(S,s) consists of one group of the type S6(2), two conjugate groups of the type 26:A8, two conjugate groups of the type A9, and one group of each of the types (3 ×U4(2)):2 = (3 ×Ω−(6,2)):2 and (A5 ×A5):22 = (Ω−(4,2) ×Ω−(4,2)):22.
(c) P(S) = 29/42, and this value is attained exactly for P(S,s) with s of order 15.
(d) Let x, y ∈ S such that x, y, x y lie in the unique involution class of length 1 575 of S. (This is the class `2A`.) Then each element in S together with one of x, y, x y generates a proper subgroup of S.
(e) Both the spread and the uniform spread of S is exactly two, with s of order 15.
(f) For each choice of s ∈ S, there is an extension S.2 such that for any element g in the (outer) class `2F`, 〈s, g 〉 does not contain S.
(g) For an element s of order 15 in S, either S is the only maximal subgroup of S.2 that contains s, or the maximal subgroups of S.2 that contain s are S and the extensions of the subgroups listed in statement (b); these groups have the structures S6(2) ×2, 26:S8 (twice), S9 (twice), S3 ×U4(2).2, and
(h) For s ∈ S of order 15 and arbitrary g ∈ S.3 \S, we have 〈s, g 〉 = S.3.
(i) If x, y are nonidentity elements in Aut(S) then there is an element s of order 15 in S such that S ⊆ 〈x, s 〉∩〈y, s 〉.

Statement (a) follows from inspection of the primitive permutation characters, cf. Section 4.3.

        gap> t:= CharacterTable( "O8+(2)" );;
        gap> ProbGenInfoSimple( t );
        [ "O8+(2)", 334/315, 0, [ "15A", "15B", "15C" ], [ 7, 7, 7 ] ]

Statement (b) can be read off from the permutation characters, and the fact that the only classes of maximal subgroups that contain elements of order 15 consist of groups of the structures as claimed, see [CCN+85,p. 85].

        gap> prim:= PrimitivePermutationCharacters( t );;
        gap> spos:= Position( OrdersClassRepresentatives( t ), 15 );;
        gap> List( Filtered( prim, x -> x[ spos ] <> 0 ), l -> l{ [ 1, spos ] } );
        [ [ 120, 1 ], [ 135, 2 ], [ 960, 2 ], [ 1120, 1 ], [ 12096, 1 ] ]

For the remaining statements, we take a primitive permutation representation on 120 points, and assume that the permutation character is `1a+35a+84a`. (See [CCN+85,p. 85], note that the three classes of maximal subgroups of index 120 in S are conjugate under triality.)

        gap> matgroup:= DerivedSubgroup( GeneralOrthogonalGroup( 1, 8, 2 ) );;
        gap> points:= NormedRowVectors( GF(2)^8 );;
        gap> orbs:= Orbits( matgroup, points );;
        gap> List( orbs, Length );
        [ 135, 120 ]
        gap> g:= Action( matgroup, orbs[2] );;
        gap> Size( g );
        174182400
        gap> pi:= Sum( Irr( t ){ [ 1, 3, 7 ] } );
        Character( CharacterTable( "O8+(2)" ), [ 120, 24, 32, 0, 0, 8, 36, 0, 0, 3,
          6, 12, 4, 8, 0, 0, 0, 10, 0, 0, 12, 0, 0, 8, 0, 0, 3, 6, 0, 0, 2, 0, 0, 2,
          1, 2, 2, 3, 0, 0, 2, 0, 0, 0, 0, 0, 3, 2, 0, 0, 1, 0, 0 ] )

In order to show statement (c), we first observe that for s in the class `15A` and g not in one of the classes `2A`, `2B`, `3A`, σ(g,s) < 1/3 holds, and for the exceptional three classes, we have σ(g,s) > 1/2.

        gap> approx:= ApproxP( prim, spos );;
        gap> testpos:= PositionsProperty( approx, x -> x >= 1/3 );
        [ 2, 3, 7 ]
        gap> AtlasClassNames( t ){ testpos };
        [ "2A", "2B", "3A" ]
        gap> approx{ testpos };
        [ 254/315, 334/315, 1093/1120 ]
        gap> ForAll( approx{ testpos }, x -> x > 1/2 );
        true

Now we compute the values P(g,s), for s in the class `15A` and g in one of the classes `2A`, `2B`, `3A`.
By our choice of the character of the permutation representation we use, the class `15A` is determined as the unique class of element order 15 with one fixed point. (Note that the three classes of element order 15 in S are conjugate under triality.) A `2A` element can be found as the fourth power of any element of order 8 in S, a `3A` element can be found as the fifth power of a `15A` element, and a `2B` element can be found as the sixth power of an element of order 12, with 32 fixed points.

        gap> ResetGlobalRandomNumberGenerators();
        gap> repeat s:= Random( g );
        >    until Order( s ) = 15 and NrMovedPoints( g ) = 1 + NrMovedPoints( s );
        gap> 3A:= s^5;;
        gap> repeat x:= Random( g ); until Order( x ) = 8;
        gap> 2A:= x^4;;
        gap> repeat x:= Random( g ); until Order( x ) = 12 and
        >      NrMovedPoints( g ) = 32 + NrMovedPoints( x^6 );
        gap> 2B:= x^6;;
        gap> prop15A:= List( [ 2A, 2B, 3A ],
        >                    x -> RatioOfNongenerationTransPermGroup( g, x, s ) );
        [ 23/35, 29/42, 149/224 ]
        gap> Maximum( prop15A );
        29/42

This means that for s in the class `15A`, we have P( S, s ) = 29/42, and the same holds for all s of order 15 since the three classes of element order 15 are conjugate under triality. Now we show that for s of order different from 15, the value P(g,s) is larger than 29/42, for g in one of the classes `2A`, `2B`, `3A`, or their images under triality. This implies statement (c).

        gap> test:= List( [ 2A, 2B, 3A ], x -> ConjugacyClass( g, x ) );;
        gap> ccl:= ConjugacyClasses( g );;
        gap> consider:= Filtered( ccl, c -> Size( c ) in List( test, Size ) );;
        gap> Length( consider );
        7
        gap> filt:= Filtered( ccl, c -> ForAll( consider, cc ->
        >       RatioOfNongenerationTransPermGroup( g, Representative( cc ),
        >           Representative( c ) ) <= 29/42 ) );;
        gap> Length( filt );
        3
        gap> List( filt, c -> Order( Representative( c ) ) );
        [ 15, 15, 15 ]

Now we show statement (d). First we observe that all those Klein four groups in S whose involutions lie in the class `2A` are conjugate in S. Note that this is the unique class of length 1 575 in S, and also the unique class whose elements have 24 fixed points in the degree 120 permutation representation.
For that, we use the character table of S to read off that S contains exactly 14 175 such subgroups, and we use the group to compute one such subgroup and its normalizer of index 14 175.

        gap> SizesConjugacyClasses( t );
        [ 1, 1575, 3780, 3780, 3780, 56700, 2240, 2240, 2240, 89600, 268800, 37800,
          340200, 907200, 907200, 907200, 2721600, 580608, 580608, 580608, 100800,
          100800, 100800, 604800, 604800, 604800, 806400, 806400, 806400, 806400,
          2419200, 2419200, 2419200, 7257600, 24883200, 5443200, 5443200, 6451200,
          6451200, 6451200, 8709120, 8709120, 8709120, 1209600, 1209600, 1209600,
          4838400, 7257600, 7257600, 7257600, 11612160, 11612160, 11612160 ]
        gap> NrPolyhedralSubgroups( t, 2, 2, 2 );
        rec( number := 14175, type := "V4" )
        gap> repeat x:= Random( g );
        >    until     Order( x ) mod 2 = 0
        >          and NrMovedPoints( x^( Order(x)/2 ) ) = 120 - 24;
        gap> x:= x^( Order(x)/2 );;
        gap> repeat y:= x^Random( g );
        >    until NrMovedPoints( x*y ) = 120 - 24;
        gap> v4:= SubgroupNC( g, [ x, y ] );;
        gap> n:= Normalizer( g, v4 );;
        gap> Index( g, n );
        14175

We verify that the triple has the required property.

        gap> maxorder:= RepresentativesMaximallyCyclicSubgroups( t );;
        gap> maxorderreps:= List( ClassesPerhapsCorrespondingToTableColumns( g, t,
        >        maxorder ), Representative );;
        gap> Length( maxorderreps );
        28
        gap> CommonGeneratorWithGivenElements( g, maxorderreps, [ x, y, x*y ] );
        fail

For the simple group S, it remains to show statement (e). We want to show that for any choice of two nonidentity elements x, y in S, there is an element s in the class `15A` such that 〈s, x 〉 = 〈s, y 〉 = S holds. Only x, y in the classes given by the list `testpos` must be considered, by the estimates σ(g,s).
We replace the values σ(g,s) by the exact values P(g,s), for g in one of these three classes. Each of the three classes is determined by its element order and its number of fixed points.

        gap> reps:= List( ccl, Representative );;
        gap> bading:= List( testpos, i -> Filtered( reps,
        >        r -> Order( r ) = OrdersClassRepresentatives( t )[i] and
        >             NrMovedPoints( r ) = 120 - pi[i] ) );;
        gap> List( bading, Length );
        [ 1, 1, 1 ]
        gap> bading:= List( bading, x -> x[1] );;

For each pair (C1, C2) of classes represented by this list, we have to show that for any choice of elements x ∈ C1, y ∈ C2 there is s in the class `15A` such that 〈s, x 〉 = 〈s, y 〉 = S holds. This is done with the random approach that is described in Section 3.3.

        gap> for pair in UnorderedTuples( bading, 2 ) do
        >      test:= RandomCheckUniformSpread( g, pair, s, 80 );
        >      if test <> true then
        >        Error( test );
        >      fi;
        >    od;

We get no error message, so statement (e) holds.
Now we turn to the automorphic extensions of S. First we compute a permutation representation of SO+(8,2) ≅ S.2 and an element g in the class `2F`, which is the unique conjugacy class of size 120 in S.2.

        gap> matgrp:= SO(1,8,2);;
        gap> g2:= Image( IsomorphismPermGroup( matgrp ) );;
        gap> IsTransitive( g2, MovedPoints( g2 ) );
        true
        gap> repeat x:= Random( g2 ); until Order( x ) = 14;
        gap> 2F:= x^7;;
        gap> Size( ConjugacyClass( g2, 2F ) );
        120

Only for s in six conjugacy classes of S, there is a nonzero probability to have S.2 = 〈g, s 〉.

        gap> der:= DerivedSubgroup( g2 );;
        gap> cclreps:= List( ConjugacyClasses( der ), Representative );;
        gap> nongen:= List( cclreps,
        >               x -> RatioOfNongenerationTransPermGroup( g2, 2F, x ) );;
        gap> goodpos:= PositionsProperty( nongen, x -> x < 1 );;
        gap> invariants:= List( goodpos, i -> [ Order( cclreps[i] ),
        >      Size( Centralizer( g2, cclreps[i] ) ), nongen[i] ] );;
        gap> SortedList( invariants );
        [ [ 10, 20, 1/3 ], [ 10, 20, 1/3 ], [ 12, 24, 2/5 ], [ 12, 24, 2/5 ],
          [ 15, 15, 0 ], [ 15, 15, 0 ] ]

S contains three classes of element order 10, which are conjugate in S.3. For a fixed extension of the type S.2, the element s can be chosen only in two of these three classes, which means that there is another group of the type S.2 (more precisely, another subgroup of index three in S.S3) in which this choice of s is not suitable - note that the general aim is to find s ∈ S uniformly for all automorphic extensions of S. Analogous statements hold for the other possibilities for s, so statement (f) follows.
Statement (g) follows from the list of maximal subgroups in [CCN+85,p. 85].
Statement (h) follows from the fact that S is the only maximal subgroup of S.3 that contains elements of order 15, according to the list of maximal subgroups in [CCN+85,p. 85]. Alternatively, if we do not want to assume this information, we can use explicit computations, as follows. All we have to check is that any element in the classes `3F` and `3G` generates S.3 together with a fixed element of order 15 in S.
We compute a permutation representation of S.3 as the derived subgroup of a subgroup of the type S.S3 inside the sporadic simple Fischer group Fi22; these subgroups lie in the fourth class of maximal subgroups of Fi22, see [CCN+85,p. 163]. An element in the class `3F` of S.3 can be found as a power of an order 21 element, and an element in the class `3G` can be found as the fourth power of a `12P` element.

        gap> aut:= Group( AtlasGenerators( "Fi22", 1, 4 ).generators );;
        gap> Size( aut ) = 6 * Size( t );
        true
        gap> g3:= DerivedSubgroup( aut );;
        gap> orbs:= Orbits( g3, MovedPoints( g3 ) );;
        gap> List( orbs, Length );
        [ 3150, 360 ]
        gap> g3:= Action( g3, orbs[2] );;
        gap> repeat s:= Random( g3 ); until Order( s ) = 15;
        gap> repeat x:= Random( g3 ); until Order( x ) = 21;
        gap> 3F:= x^7;;
        gap> RatioOfNongenerationTransPermGroup( g3, 3F, s );
        0
        gap> repeat x:= Random( g3 );
        >    until Order( x ) = 12 and Size( Centralizer( g3, x^4 ) ) = 648;
        gap> 3G:= x^4;;
        gap> RatioOfNongenerationTransPermGroup( g3, 3G, s );
        0

Finally, consider statement (i). It implies that [BGK08,Corollary 1.5] holds for Ω+(8,2), with s of order 15. Note that by part (f), s cannot be chosen in a prescribed conjugacy class of S that is independent of the elements x, y.
If x and y lie in S then statement (i) follows from part (e), and by part (g), the case that x or y lie in S.3 \S is also not a problem. We now show that also x or y in S.2 \S is not a problem. Here we have to deal with the cases that x and y lie in the same subgroup of index 3 in Aut(S) or in different such subgroups. Actually we show that for each index 3 subgroup H = S.2 < Aut(S), we can choose s from two of the three classes of element order 15 in S such that S is the only maximal subgroup of H that contains s, and thus 〈x, s 〉 contains H, for any choice of x ∈ H \S.
For that, we note that no novelty in S.2 contains elements of order 15, so all maximal subgroups of S.2 that contain such elements -besides S- have one of the indices 120, 135, 960, 1120, or 12096, and point stabilizers of the types S6(2) ×2, 26:S8, S9, S3 ×U4(2):2, or S5 ≀ 2. We compute the corresponding permutation characters.

        gap> t2:= CharacterTable( "O8+(2).2" );;
        gap> s:= CharacterTable( "S6(2)" ) * CharacterTable( "Cyclic", 2 );;
        gap> pi:= PossiblePermutationCharacters( s, t2 );;
        gap> prim:= pi;;
        gap> pi:= PermChars( t2, rec( torso:= [ 135 ] ) );;
        gap> Append( prim, pi );
        gap> pi:= PossiblePermutationCharacters( CharacterTable( "A9.2" ), t2 );;
        gap> Append( prim, pi );
        gap> s:= CharacterTable( "Dihedral(6)" ) * CharacterTable( "U4(2).2" );;
        gap> pi:= PossiblePermutationCharacters( s, t2 );;
        gap> Append( prim, pi );
        gap> s:= CharacterTableWreathSymmetric( CharacterTable( "S5" ), 2 );;
        gap> pi:= PossiblePermutationCharacters( s, t2 );;
        gap> Append( prim, pi );
        gap> Length( prim );
        5
        gap> ord15:= PositionsProperty( OrdersClassRepresentatives( t2 ),
        >                               x -> x = 15 );
        [ 39, 40 ]
        gap> List( prim, pi -> pi{ ord15 } );
        [ [ 1, 0 ], [ 2, 0 ], [ 2, 0 ], [ 1, 0 ], [ 1, 0 ] ]
        gap> List( ord15, i -> Maximum( ApproxP( prim, i ) ) );
        [ 307/120, 0 ]

Here it is appropriate to clean the workspace again.

        gap> CleanWorkspace();

### 5.13 O8+(3)

We show that S = O8+(3) satisfies the following.

(a) σ(S) = 863/1820, and this value is attained exactly for σ(S,s) with s of order 20.
(b) For s ∈ S of order 20, M(S,s) consists of two nonconjugate groups of the type O7(3) = Ω(7,3), two conjugate subgroups of the type 36:L4(3), two nonconjugate subgroups of the type (A4 ×U4(2)):2, and one subgroup of each of the types 2.U4(3).(22)122 and (A6 ×A6):22.
(c) P(S) = 194/455, and this value is attained exactly for P(S,s) with s of order 20.
(d) The uniform spread of S is at least three, with s of order 20.
(e) The preimage of s in the matrix group 2.S = Ω+(8,3) can be chosen of order 40, and then the maximal subgroups of 2.S containing s have the structures 2.O7(3), 36:2.L4(3), 4.U4(3).22 = SU(4,3).22, 2.(A4 ×U4(2)).2 = 2.(PSp(2,3) ⊗PSp(4,3)).2, and 2.(A6 ×A6):22 = 2.(Ω−(4,3) ×Ω−(4,3)):22, respectively.
(f) For s ∈ S of order 20, we have P′(S.21, s) ∈ { 83/567, 574/1215 }, P′(S.22, s) ∈ { 0, 1 } (depending on the choice of s), and σ′(S.3, s) = 0.
Furthermore, for any choice of s′ ∈ S, we have σ′(S.22, s′) = 1 for some group S.22. However, if it is allowed to choose s from an Aut(S)-class of elements of order 20 (and not from a fixed S-class) then we can achieve σ(g,s) = 0 for any given g ∈ S.22 \S.
(g) The maximal subgroups of S.21 that contain an element of order 20 are either S and the extensions of the subgroups listed in statement (b) or they are S and L4(3).22, 36:L4(3).2 (twice), 2.U4(3).(22)122.2, and (A6 ×A6):22.2.
In the former case, the groups have the structures O7(3):2 (twice), 36:(L4(3) ×2) (twice), S4 ×U4(2).2 (twice), 2.U4(3).(22)122.2, and (A6 ×A6):22 ×2.

Statement (a) follows from inspection of the primitive permutation characters.

        gap> t:= CharacterTable( "O8+(3)" );;
        gap> ProbGenInfoSimple( t );
        [ "O8+(3)", 863/1820, 2, [ "20A", "20B", "20C" ], [ 8, 8, 8 ] ]

Also statement (b) follows from the information provided by the character table of S (cf. [CCN+85,p. 140]).

        gap> prim:= PrimitivePermutationCharacters( t );;
        gap> ord:= OrdersClassRepresentatives( t );;
        gap> spos:= Position( ord, 20 );;
        gap> filt:= PositionsProperty( prim, x -> x[ spos ] <> 0 );
        [ 1, 2, 7, 15, 18, 19, 24 ]
        gap> Maxes( t ){ filt };
        [ "O7(3)", "O8+(3)M2", "3^6:L4(3)", "2.U4(3).(2^2)_{122}", "(A4xU4(2)):2",
          "O8+(3)M19", "(A6xA6):2^2" ]
        gap> prim{ filt }{ [ 1, spos ] };
        [ [ 1080, 1 ], [ 1080, 1 ], [ 1120, 2 ], [ 189540, 1 ], [ 7960680, 1 ],
          [ 7960680, 1 ], [ 9552816, 1 ] ]

For statement (c), we first show that P(S,s) = 194/455 holds. Since this value is larger than 1/3, we have to inspect only those classes gS for which σ(g,s) ≥ 1/3 holds,

        gap> ord:= OrdersClassRepresentatives( t );;
        gap> ord20:= PositionsProperty( ord, x -> x = 20 );;
        gap> cand:= [];;
        gap> for i in ord20 do
        >      approx:= ApproxP( prim, i );
        >      Add( cand, PositionsProperty( approx, x -> x >= 1/3 ) );
        >    od;
        gap> cand;
        [ [ 2, 6, 7, 10 ], [ 3, 6, 8, 11 ], [ 4, 6, 9, 12 ] ]
        gap> AtlasClassNames( t ){ cand[1] };
        [ "2A", "3A", "3B", "3E" ]

The three possibilities form one orbit under the outer automorphism group of S.

        gap> t3:= CharacterTable( "O8+(3).3" );;
        gap> tfust3:= GetFusionMap( t, t3 );;
        gap> List( cand, x -> tfust3{ x } );
        [ [ 2, 4, 5, 6 ], [ 2, 4, 5, 6 ], [ 2, 4, 5, 6 ] ]

By symmetry, we may consider only the first possibility, and assume that s is in the class `20A`.
We work with a permutation representation of degree 1 080, and assume that the permutation character is `1a+260a+819a`. (Note that all permutation characters of S of degree 1 080 are conjugate under Aut(S).)

        gap> g:= Action( SO(1,8,3), NormedRowVectors( GF(3)^8 ), OnLines );;
        gap> Size( g );
        9904359628800
        gap> g:= DerivedSubgroup( g );;  Size( g );
        4952179814400
        gap> orbs:= Orbits( g, MovedPoints( g ) );;
        gap> List( orbs, Length );
        [ 1080, 1080, 1120 ]
        gap> g:= Action( g, orbs[1] );;
        gap> PositionProperty( Irr( t ), chi -> chi[1] = 819 );
        9
        gap> permchar:= Sum( Irr( t ){ [ 1, 2, 9 ] } );
        Character( CharacterTable( "O8+(3)" ), [ 1080, 128, 0, 0, 24, 108, 135, 0, 0,
          108, 0, 0, 27, 27, 0, 0, 18, 9, 12, 16, 0, 0, 4, 15, 0, 0, 20, 0, 0, 12,
          11, 0, 0, 20, 0, 0, 15, 0, 0, 12, 0, 0, 2, 0, 0, 3, 3, 0, 0, 6, 6, 0, 0, 3,
          2, 2, 2, 18, 0, 0, 9, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 3, 0, 0, 12, 0, 0, 3,
          0, 0, 0, 0, 0, 4, 3, 3, 0, 0, 1, 0, 0, 4, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0, 3,
          0, 0, 2, 0, 0, 5, 0, 0, 1, 0, 0 ] )

Now we show that for s in the class `20A` (which fixes one point), the proportion of nongenerating elements g in one of the classes `2A`, `3A`, `3B`, `3E` has the maximum 194/455, which is attained exactly for `3A`. (We find a `2A` element as a power of s, a `3A` element as a power of any element of order 18, a `3B` and a `3E` element as elements with 135 and 108 fixed points, respectively, which occur as powers of suitable elements of order 15.)

        gap> permchar{ ord20 };
        [ 1, 0, 0 ]
        gap> AtlasClassNames( t )[ PowerMap( t, 10 )[ ord20[1] ] ];
        "2A"
        gap> ord18:= PositionsProperty( ord, x -> x = 18 );;
        gap> Set( AtlasClassNames( t ){ PowerMap( t, 6 ){ ord18 } } );
        [ "3A" ]
        gap> ord15:= PositionsProperty( ord, x -> x = 15 );;
        gap> PowerMap( t, 5 ){ ord15 };
        [ 7, 8, 9, 10, 11, 12 ]
        gap> AtlasClassNames( t ){ [ 7 .. 12 ] };
        [ "3B", "3C", "3D", "3E", "3F", "3G" ]
        gap> permchar{ [ 7 .. 12 ] };
        [ 135, 0, 0, 108, 0, 0 ]
        gap> mp:= NrMovedPoints( g );;
        gap> ResetGlobalRandomNumberGenerators();
        gap> repeat 20A:= Random( g );
        >    until Order( 20A ) = 20 and mp - NrMovedPoints( 20A ) = 1;
        gap> 2A:= 20A^10;;
        gap> repeat x:= Random( g ); until Order( x ) = 18;
        gap> 3A:= x^6;;
        gap> repeat x:= Random( g );
        >    until Order( x ) = 15 and mp - NrMovedPoints( x^5 ) = 135;
        gap> 3B:= x^5;;
        gap> repeat x:= Random( g );
        >    until Order( x ) = 15 and mp - NrMovedPoints( x^5 ) = 108;
        gap> 3E:= x^5;;
        gap> nongen:= List( [ 2A, 3A, 3B, 3E ],
        >                   c -> RatioOfNongenerationTransPermGroup( g, c, 20A ) );
        [ 3901/9477, 194/455, 451/1092, 451/1092 ]
        gap> Maximum( nongen );
        194/455

Next we compute the values P(g,s), for g is in the class `3A` and certain elements s. It is enough to consider representatives s of maximally cyclic subgroups in S, but here we can do better, as follows. Since `3A` is the unique class of length 72 800, it is fixed under Aut(S), so it is enough to consider one element s from each Aut(S)-orbit on the classes of S. We use the class fusion between the character tables of S and Aut(S) for computing orbit representatives.

        gap> maxorder:= RepresentativesMaximallyCyclicSubgroups( t );;
        gap> Length( maxorder );
        57
        gap> autt:= CharacterTable( "O8+(3).S4" );;
        gap> fus:= PossibleClassFusions( t, autt );;
        gap> orbreps:= Set( List( fus, map -> Set( ProjectionMap( map ) ) ) );
        [ [ 1, 2, 5, 6, 7, 13, 17, 18, 19, 20, 23, 24, 27, 30, 31, 37, 43, 46, 50,
              54, 55, 56, 57, 58, 64, 68, 72, 75, 78, 84, 85, 89, 95, 96, 97, 100,
              106, 112 ] ]
        gap> totest:= Intersection( maxorder, orbreps[1] );
        [ 43, 50, 54, 56, 57, 64, 68, 75, 78, 84, 85, 89, 95, 97, 100, 106, 112 ]
        gap> Length( totest );
        17
        gap> AtlasClassNames( t ){ totest };
        [ "6Q", "6X", "6B1", "8A", "8B", "9G", "9K", "12A", "12D", "12J", "12K",
          "12O", "13A", "14A", "15A", "18A", "20A" ]

This means that we have to test one element of each of the element orders 13, 14, 15, and 18 (note that we know already a bound for elements of order 20), plus certain elements of the orders 6, 8, 9, and 12 which can be identified by their centralizer orders and (for elements of order 6 and 8) perhaps the centralizer orders of some powers.

        gap> elementstotest:= [];;
        gap> for elord in [ 13, 14, 15, 18 ] do
        >      repeat s:= Random( g );
        >      until Order( s ) = elord;
        >      Add( elementstotest, s );
        >    od;

The next elements to be tested are in the classes `6B1` (centralizer order 162), in one of `9G`-`9J` (centralizer order 729), in one of `9K`-`9N` (centralizer order 81), in one of `12A`-`12C` (centralizer order 1 728), in one of `12D`-`12I` (centralizer order 432), in `12J` (centralizer order 192), in one of `12K`-`12N` (centralizer order 108), and in one of `12O`-`12T` (centralizer order 72).

        gap> ordcent:= [ [ 6, 162 ], [ 9, 729 ], [ 9, 81 ], [ 12, 1728 ],
        >                [ 12, 432 ], [ 12, 192 ], [ 12, 108 ], [ 12, 72 ] ];;
        gap> cents:= SizesCentralizers( t );;
        gap> for pair in ordcent do
        >      Print( pair, ": ", AtlasClassNames( t ){
        >          Filtered( [ 1 .. Length( ord ) ],
        >                    i -> ord[i] = pair[1] and cents[i] = pair[2] ) }, "\n" );
        >      repeat s:= Random( g );
        >      until Order( s ) = pair[1] and Size( Centralizer( g, s ) ) = pair[2];
        >      Add( elementstotest, s );
        >    od;
        [ 6, 162 ]: [ "6B1" ]
        [ 9, 729 ]: [ "9G", "9H", "9I", "9J" ]
        [ 9, 81 ]: [ "9K", "9L", "9M", "9N" ]
        [ 12, 1728 ]: [ "12A", "12B", "12C" ]
        [ 12, 432 ]: [ "12D", "12E", "12F", "12G", "12H", "12I" ]
        [ 12, 192 ]: [ "12J" ]
        [ 12, 108 ]: [ "12K", "12L", "12M", "12N" ]
        [ 12, 72 ]: [ "12O", "12P", "12Q", "12R", "12S", "12T" ]

The next elements to be tested are in one of the classes `6Q`-`6S` (centralizer order 648).

        gap> AtlasClassNames( t ){ Filtered( [ 1 .. Length( ord ) ],
        >        i -> cents[i] = 648 and cents[ PowerMap( t, 2 )[i] ] = 52488
        >                            and cents[ PowerMap( t, 3 )[i] ] = 26127360 ) };
        [ "6Q", "6R", "6S" ]
        gap> repeat s:= Random( g );
        >    until Order( s ) = 6 and Size( Centralizer( g, s ) ) = 648
        >      and Size( Centralizer( g, s^2 ) ) = 52488
        >      and Size( Centralizer( g, s^3 ) ) = 26127360;
        gap> Add( elementstotest, s );

The next elements to be tested are in the class `6X`-`6A1` (centralizer order 648).

        gap> AtlasClassNames( t ){ Filtered( [ 1 .. Length( ord ) ],
        >        i -> cents[i] = 648 and cents[ PowerMap( t, 2 )[i] ] = 52488
        >                            and cents[ PowerMap( t, 3 )[i] ] = 331776 ) };
        [ "6X", "6Y", "6Z", "6A1" ]
        gap> repeat s:= Random( g );
        >    until Order( s ) = 6 and Size( Centralizer( g, s ) ) = 648
        >      and Size( Centralizer( g, s^2 ) ) = 52488
        >      and Size( Centralizer( g, s^3 ) ) = 331776;
        gap> Add( elementstotest, s );

Finally, we add elements from the classes `8A` and `8B`.

        gap> AtlasClassNames( t ){ Filtered( [ 1 .. Length( ord ) ],
        >        i -> ord[i] = 8 and cents[ PowerMap( t, 2 )[i] ] = 13824 ) };
        [ "8A" ]
        gap> repeat s:= Random( g );
        >    until Order( s ) = 8 and Size( Centralizer( g, s^2 ) ) = 13824;
        gap> Add( elementstotest, s );
        gap> AtlasClassNames( t ){ Filtered( [ 1 .. Length( ord ) ],
        >        i -> ord[i] = 8 and cents[ PowerMap( t, 2 )[i] ] = 1536 ) };
        [ "8B" ]
        gap> repeat s:= Random( g );
        >    until Order( s ) = 8 and Size( Centralizer( g, s^2 ) ) = 1536;
        gap> Add( elementstotest, s );

Now we compute the ratios. It turns out that from these candidates, only elements s of the orders 14 and 15 satisfy P(g,s) < 194/455.

        gap> nongen:= List( elementstotest,
        >                   s -> RatioOfNongenerationTransPermGroup( g, 3A, s ) );;
        gap> smaller:= PositionsProperty( nongen, x -> x < 194/455 );
        [ 2, 3 ]
        gap> nongen{ smaller };
        [ 127/325, 1453/3640 ]

So the only candidates for s that may be better than order 20 elements are elements of order 14 or 15. In order to exclude these two possibilities, we compute P(g,s) for s in the class `14A` and g = s7 in the class `2A`, and for s in the class `15A` and g in the class `2A`, which yields values that are larger than 194/455.

        gap> repeat s:= Random( g );
        >    until Order( s ) = 14 and NrMovedPoints( s ) = 1078;
        gap> 2A:= s^7;;
        gap> nongen:= RatioOfNongenerationTransPermGroup( g, 2A, s );
        1573/3645
        gap> nongen > 194/455;
        true
        gap> repeat s:= Random( g );
        >    until Order( s ) = 15 and NrMovedPoints( s ) = 1080 - 3;
        gap> nongen:= RatioOfNongenerationTransPermGroup( g, 2A, s );
        490/1053
        gap> nongen > 194/455;
        true

For statement (d), we show that for each triple of elements in the union of the classes `2A`, `3A`, `3B`, `3E` there is an element in the class `20A` that generates S together with each element of the triple.

        gap> for tup in UnorderedTuples( [ 2A, 3A, 3B, 3E ], 3 ) do
        >      cl:= ShallowCopy( tup );
        >      test:= RandomCheckUniformSpread( g, cl, 20A, 100 );
        >      if test <> true then
        >        Error( test );
        >      fi;
        >    od;

We get no error message, so statement (d) is true.
For statement (e), first we show that 2.S = Ω+(8,3) contains elements of order 40 but S does not.

        gap> der:= DerivedSubgroup( SO(1,8,3) );;
        gap> repeat x:= PseudoRandom( der ); until Order( x ) = 40;
        gap> 40 in ord;
        false

Thus elements of order 40 must arise as preimages of order 20 elements under the natural epimorphism from 2.S to S, which means that we may choose an order 40 preimage [^s] of s. Then M(2.S, [^s]) consists of central extensions of the subgroups listed in statement (b). The perfect subgroups O7(3), L4(3), 2.U4(3), and U4(2) of these groups must lift to their Schur double covers in 2.S because otherwise the preimages would not contain elements of order 40.
Next we consider the preimage of the subgroup U = (A4 ×U4(2)).2 of S. We show that the preimages of the two direct factors A4 and U4(2) in U′ = A4 ×U4(2) are Schur covers. For A4, this follows from the fact that the preimage of U′ must contain elements of order 20, and that U4(2) does not contain elements of order 10.

        gap> u42:= CharacterTable( "U4(2)" );;
        gap> Filtered( OrdersClassRepresentatives( u42 ), x -> x mod 5 = 0 );
        [ 5 ]

In order to show that the U4(2) type subgroup of U′ lifts to its double cover in 2.S, we note that the class `2B` of U4(2) lifts to a class of elements of order four in the double cover 2.U4(2), and that the corresponding class of elements in U is S-conjugate to the class of involutions in the direct factor A4 (which is the unique class of length three in U).

        gap> u:= CharacterTable( Maxes( t )[18] );
        CharacterTable( "(A4xU4(2)):2" )
        gap> 2u42:= CharacterTable( "2.U4(2)" );;
        gap> OrdersClassRepresentatives( 2u42 )[4];
        4
        gap> GetFusionMap( 2u42, u42 )[4];
        3
        gap> OrdersClassRepresentatives( u42 )[3];
        2
        gap> List( PossibleClassFusions( u42, u ), x -> x[3] );
        [ 8 ]
        gap> PositionsProperty( SizesConjugacyClasses( u ), x -> x = 3 );
        [ 2 ]
        gap> ForAll( PossibleClassFusions( u, t ), x -> x[2] = x[8] );
        true

The last subgroup for which the structure of the preimage has to be shown is U = (A6 ×A6):22. We claim that each of the A6 type subgroups in the derived subgroup U′ = A6 ×A6 lifts to its double cover in 2.S. Since all elements of order 20 in U lie in U′, at least one of the two direct factors must lift to its double cover, in order to give rise to an order 40 element in U. In fact both factors lift to the double cover since the two direct factors are interchanged by conjugation in U; the latter follows form tha fact that U has no normal subgroup of type A6.

        gap> u:= CharacterTable( Maxes( t )[24] );
        CharacterTable( "(A6xA6):2^2" )
        gap> ClassPositionsOfDerivedSubgroup( u );
        [ 1 .. 22 ]
        gap> PositionsProperty( OrdersClassRepresentatives( u ), x -> x = 20 );
        [ 8 ]
        gap> List( ClassPositionsOfNormalSubgroups( u ),
        >          x -> Sum( SizesConjugacyClasses( u ){ x } ) );
        [ 1, 129600, 259200, 259200, 259200, 518400 ]

So statement (e) holds.
For statement (f), we have to consider the upward extensions S.21, S.22, and S.3.
First we look at S.21, an extension by an outer automorphism that acts as a double transposition in the outer automorphism group S4. Note that the symmetry between the three classes of element oder 20 in S is broken in S.21, two of these classes have square roots in S.21, the third has not.

        gap> t2:= CharacterTable( "O8+(3).2_1" );;
        gap> ord20:= PositionsProperty( OrdersClassRepresentatives( t2 ),
        >                x -> x = 20 );;
        gap> ord20:= Intersection( ord20, ClassPositionsOfDerivedSubgroup( t2 ) );
        [ 84, 85, 86 ]
        gap> List( ord20, x -> x in PowerMap( t2, 2 ) );
        [ false, true, true ]

Changing the viewpoint, we see that for each class of element order 20 in S, there is a group of the type S.21 in which the elements in this class do not have square roots, and there are groups of this type in which these elements have square roots. So we have to deal with two different cases, and we do this by first collecting the permutation characters induced from all maximal subgroups of S.21 (other than S) that contain elements of order 20 in S, and then considering s in each of these classes of S.
We fix an embedding of S into S.21 in which the elements in the class `20A` do not have square roots. This situation is given for the stored class fusion between the tables in the GAP Character Table Library.

        gap> tfust2:= GetFusionMap( t, t2 );;
        gap> tfust2{ PositionsProperty( OrdersClassRepresentatives( t ),
        >                x -> x = 20 ) };
        [ 84, 85, 86 ]

The six different actions of S on the cosets of O7(3) type subgroups induce pairwise different permutation characters that form an orbit under the action of Aut(S). Four of these characters cannot extend to S.21, the other two extend to permutation characters of S.21 on the cosets of O7(3).2 type subgroups; these subgroups contain `20A` elements.

        gap> primt2:= [];;
        gap> poss:= PossiblePermutationCharacters( CharacterTable( "O7(3)" ), t );;
        gap> invfus:= InverseMap( tfust2 );;
        gap> List( poss, pi -> ForAll( CompositionMaps( pi, invfus ), IsInt ) );
        [ false, false, false, false, true, true ]
        gap> PossiblePermutationCharacters(
        >        CharacterTable( "O7(3)" ) * CharacterTable( "Cyclic", 2 ), t2 );
        [  ]
        gap> ext:= PossiblePermutationCharacters( CharacterTable( "O7(3).2" ), t2 );;
        gap> List( ext, pi -> pi{ ord20 } );
        [ [ 1, 0, 0 ], [ 1, 0, 0 ] ]
        gap> Append( primt2, ext );

The novelties in S.21 that arise from O7(3) type subgroups of S have the structure L4(3).22. These subgroups contain elements in the classes `20B` and `20C` of S.

        gap> ext:= PossiblePermutationCharacters( CharacterTable( "L4(3).2^2" ), t2 );;
        gap> List( ext, pi -> pi{ ord20 } );
        [ [ 0, 0, 1 ], [ 0, 1, 0 ] ]
        gap> Append( primt2, ext );

Note that from the possible permutation characters of S.21 on the cosets of L4(3):2 ×2 type subgroups, we see that such subgroups must contain `20A` elements, i. e., all such subgroups of S.21 lie inside O7(3).2 type subgroups. This means that the structure description of these novelties in [CCN+85,p. 140] is not correct. The correct structure is L4(3).22.)

        gap> List( PossiblePermutationCharacters( CharacterTable( "L4(3).2_2" ) *
        >              CharacterTable( "Cyclic", 2 ), t2 ), pi -> pi{ ord20 } );
        [ [ 1, 0, 0 ] ]

All 36:L4(3) type subgroups of S extend to S.21. We compute these permutation characters as the possible permutation characters of the right degree.

        gap> ext:= PermChars( t2, rec( torso:= [ 1120 ] ) );;
        gap> List( ext, pi -> pi{ ord20 } );
        [ [ 2, 0, 0 ], [ 0, 0, 2 ], [ 0, 2, 0 ] ]
        gap> Append( primt2, ext );

Also all 2.U4(3).22 type subgroups of S extend to S.21. We compute the permutation characters as the extensions of the corresponding permutation characters of S.

        gap> filt:= Filtered( prim, x -> x[1] = 189540 );;
        gap> cand:= List( filt, x -> CompositionMaps( x, invfus ) );;
        gap> ext:= Concatenation( List( cand,
        >              pi -> PermChars( t2, rec( torso:= pi ) ) ) );;
        gap> List( ext, x -> x{ ord20 } );
        [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ]
        gap> Append( primt2, ext );

The extensions of (A4 ×U4(2)):2 type subgroups of S to S.21 have the type S4 ×U4(2):2, they contain `20A` elements.

        gap> ext:= PossiblePermutationCharacters( CharacterTable( "Symmetric", 4 ) *
        >              CharacterTable( "U4(2).2" ), t2 );;
        gap> List( ext, x -> x{ ord20 } );
        [ [ 1, 0, 0 ], [ 1, 0, 0 ] ]
        gap> Append( primt2, ext );

All (A6 ×A6):22 type subgroups of S extend to S.21. We compute the permutation characters as the extensions of the corresponding permutation characters of S.

        gap> filt:= Filtered( prim, x -> x[1] = 9552816 );;
        gap> cand:= List( filt, x -> CompositionMaps( x, InverseMap( tfust2 ) ));;
        gap> ext:= Concatenation( List( cand,
        >              pi -> PermChars( t2, rec( torso:= pi ) ) ) );;
        gap> List( ext, x -> x{ ord20 } );
        [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ]
        gap> Append( primt2, ext );

We have found all relevant permutation characters of S.21. This together with the list in [CCN+85,p. 140] implies statement (g).
Now we compute the bounds σ′(S.21, s).

        gap> Length( primt2 );
        15
        gap> approx:= List( ord20, x -> ApproxP( primt2, x ) );;
        gap> outer:= Difference(
        >      PositionsProperty( OrdersClassRepresentatives( t2 ), IsPrimeInt ),
        >      ClassPositionsOfDerivedSubgroup( t2 ) );;
        gap> List( approx, l -> Maximum( l{ outer } ) );
        [ 574/1215, 83/567, 83/567 ]

Next we look at S.22, an extension by an outer automorphism that acts as a transposition in the outer automorphism group S4. Similar to the above situation, the symmetry between the three classes of element oder 20 in S is broken also in S.22: The first is a conjugacy class of S.22, the other two classes are fused in S.22,

        gap> t2:= CharacterTable( "O8+(3).2_2" );;
        gap> ord20:= PositionsProperty( OrdersClassRepresentatives( t2 ),
        >                x -> x = 20 );;
        gap> ord20:= Intersection( ord20, ClassPositionsOfDerivedSubgroup( t2 ) );
        [ 82, 83 ]
        gap> tfust2:= GetFusionMap( t, t2 );;
        gap> tfust2{ PositionsProperty( OrdersClassRepresentatives( t ),
        >                x -> x = 20 ) };
        [ 82, 83, 83 ]

Like in the case S.21, we compute the permutation characters induced from all maximal subgroups of S.22 (other than S) that contain elements of order 20 in S.
We fix the embedding of S into S.22 in which the class `20A` of S is a class of S.22. This situation is given for the stored class fusion between the tables in the GAP Character Table Library.
Exactly two classes of O7(3) type subgroups in S extend to S.22, these groups contain `20A` elements.

        gap> primt2:= [];;
        gap> ext:= PermChars( t2, rec( torso:= [ 1080 ] ) );;
        gap> List( ext, pi -> pi{ ord20 } );
        [ [ 1, 0 ], [ 1, 0 ] ]
        gap> Append( primt2, ext );

Only one class of 36:L4(3) type subgroups extends to S.22. (Note that we need not consider the novelties of the type 33+6:(L3(3) ×2), because the order of these groups is not divisible by 5.)

        gap> ext:= PermChars( t2, rec( torso:= [ 1120 ] ) );;
        gap> List( ext, pi -> pi{ ord20 } );
        [ [ 2, 0 ] ]
        gap> Append( primt2, ext );

Only one class of 2.U4(3).22 type subgroups of S extends to S.22. We compute the permutation character as the extension of the corresponding permutation characters of S.

        gap> filt:= Filtered( prim, x -> x[1] = 189540 );;
        gap> cand:= List( filt, x -> CompositionMaps( x, InverseMap( tfust2 ) ));;
        gap> ext:= Concatenation( List( cand,
        >              pi -> PermChars( t2, rec( torso:= pi ) ) ) );;
        gap> List( ext, x -> x{ ord20 } );
        [ [ 1, 0 ] ]
        gap> Append( primt2, ext );

Two classes of (A4 ×U4(2)):2 type subgroups of S extend to S.22.

        gap> filt:= Filtered( prim, x -> x[1] = 7960680 );;
        gap> cand:= List( filt, x -> CompositionMaps( x, InverseMap( tfust2 ) ));;
        gap> ext:= Concatenation( List( cand,
        >              pi -> PermChars( t2, rec( torso:= pi ) ) ) );;
        gap> List( ext, x -> x{ ord20 } );
        [ [ 1, 0 ], [ 1, 0 ] ]
        gap> Append( primt2, ext );

Exactly one class of (A6 ×A6):22 type subgroups in S extends to S.22, and the extensions have the structure S6 ≀ 2.

        gap> ext:= PossiblePermutationCharacters( CharacterTableWreathSymmetric(
        >              CharacterTable( "S6" ), 2 ), t2 );;
        gap> List( ext, x -> x{ ord20 } );
        [ [ 1, 0 ] ]
        gap> Append( primt2, ext );

We have found all relevant permutation characters of S.22, and compute the bounds σ′(S.22, s).

        gap> Length( primt2 );
        7
        gap> approx:= List( ord20, x -> ApproxP( primt2, x ) );;
        gap> outer:= Difference(
        >      PositionsProperty( OrdersClassRepresentatives( t2 ), IsPrimeInt ),
        >      ClassPositionsOfDerivedSubgroup( t2 ) );;
        gap> List( approx, l -> Maximum( l{ outer } ) );
        [ 14/9, 0 ]

This means that there is an extension of the type S.22 in which s cannot be chosen such that the bound is less than 1/2. More precisely, we have σ(g,s) ≥ 1/2 exactly for g in the unique outer involution class of size 1 080.

        gap> approx:= ApproxP( primt2, ord20[1] );;
        gap> bad:= Filtered( outer, i -> approx[i] >= 1/2 );
        [ 84 ]
        gap> OrdersClassRepresentatives( t2 ){ bad };
        [ 2 ]
        gap> SizesConjugacyClasses( t2 ){ bad };
        [ 1080 ]
        gap> Number( SizesConjugacyClasses( t2 ), x -> x = 1080 );
        1

So we compute the proportion of elements in this class that generate S.22 together with an element s of order 20 in S. (As above, we have to consider two conjugacy classes.) For that, we first compute a permutation representation of S.22, using that S.22 is isomporphic to the two subgroups of index 2 in PGO+(8,3) = O8+(3).22122 that are different from PSO+(8,3) = O8+(3).21, cf. [CCN+85,p. 140].

        gap> go:= GO(1,8,3);;
        gap> so:= SO(1,8,3);;
        gap> outerelm:= First( GeneratorsOfGroup( go ), x -> not x in so );;
        gap> g2:= ClosureGroup( DerivedSubgroup( so ), outerelm );;
        gap> Size( g2 );
        19808719257600
        gap> dom:= NormedVectors( GF(3)^8 );;
        gap> orbs:= Orbits( g2, dom, OnLines );;
        gap> List( orbs, Length );
        [ 1080, 1080, 1120 ]
        gap> act:= Action( g2, orbs[1], OnLines );;

An involution g can be found as a power of one of the given generators.

        gap> Order( outerelm );
        26
        gap> g:= Permutation( outerelm^13, orbs[1], OnLines );;
        gap> Size( ConjugacyClass( act, g ) );
        1080

Now we find the candidates for the elements s, and compute their ratios of nongeneration.

        gap> ord20;
        [ 82, 83 ]
        gap> SizesCentralizers( t2 ){ ord20 };
        [ 40, 20 ]
        gap> der:= DerivedSubgroup( act );;
        gap> repeat 20A:= Random( der );
        >    until Order( 20A ) = 20 and Size( Centralizer( act, 20A ) ) = 40;
        gap> RatioOfNongenerationTransPermGroup( act, g, 20A );
        1
        gap> repeat 20BC:= Random( der );
        >    until Order( 20BC ) = 20 and Size( Centralizer( act, 20BC ) ) = 20;
        gap> RatioOfNongenerationTransPermGroup( act, g, 20BC );
        0

This means that for s in one S-class of elements of order 20, we have P′(g, s) = 1, and s in the other two S-classes of elements of order 20 generates with any conjugate of g.
Concerning S.22, it remains to show that we cannot find a better element than s. For that, we first compute class representatives s′ in S, w.r.t. conjugacy in S.22, and then compute P′( s′, g ). (It would be enough to check representatives of classes of maximal element order, but computing all classes is easy enough.)

        gap> ccl:= ConjugacyClasses( act );;
        gap> der:= DerivedSubgroup( act );;
        gap> reps:= Filtered( List( ccl, Representative ), x -> x in der );;
        gap> Length( reps );
        83
        gap> ratios:= List( reps,
        >                   s -> RatioOfNongenerationTransPermGroup( act, g, s ) );;
        gap> cand:= PositionsProperty( ratios, x -> x < 1 );;
        gap> ratios:= ratios{ cand };;
        gap> SortParallel( ratios, cand );
        gap> ratios;
        [ 0, 1/10, 1/10, 16/135, 1/3, 1/3, 11/27, 7/15, 7/15 ]

For S.22, it remains to show that there is no element s′ ∈ S such that P′( s′x, g ) < 1 holds for any x ∈ Aut(S) and g ∈ S.22. So we are done when we can show that each class given by `cand` is conjugate in S.3 to a class outside `cand`. The classes can be identified by element orders and centralizer orders.

        gap> invs:= List( cand,
        >       x -> [ Order( reps[x] ), Size( Centralizer( der, reps[x] ) ) ] );
        [ [ 20, 20 ], [ 18, 108 ], [ 18, 108 ], [ 14, 28 ], [ 15, 45 ], [ 15, 45 ],
          [ 10, 40 ], [ 12, 72 ], [ 12, 72 ] ]

Namely, `cand` contains no full S.3-orbit of classes of the element orders 20, 18, 14, 15, and 10; also, `cand` does not contain full S.3-orbits on the classes `12O`-`12T`.
Finally, we deal with S.3. The fact that no maximal subgroup of S containing an element of order 20 extends to S.3 follows either from the list of maximal subgroups of S in [CCN+85,p. 140] or directly from the permutation characters.

        gap> t3:= CharacterTable( "O8+(3).3" );;
        gap> tfust3:= GetFusionMap( t, t3 );;
        gap> inv:= InverseMap( tfust3 );;
        gap> filt:= PositionsProperty( prim, x -> x[ spos ] <> 0 );;
        gap> ForAll( prim{ filt },
        >            pi -> ForAny( CompositionMaps( pi, inv ), IsList ) );
        true

So we have to consider only the classes of novelties in S.3, but the order of none of these groups is divisible by 20 -again see [CCN+85,p. 140]). This means that any element in S.3 \S together with an element of order 20 in S generates S.3. This is in fact stronger than statement (f), which claims this property only for elements of prime order in S.3 \S (and their roots); note that S.3 \S contains elements of the orders 9 and 27.

        gap> outer:= Difference( [ 1 .. NrConjugacyClasses( t3 ) ],
        >                ClassPositionsOfDerivedSubgroup( t3 ) );
        [ 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
          72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
          91, 92, 93, 94 ]
        gap> Set( OrdersClassRepresentatives( t3 ){ outer } );
        [ 3, 6, 9, 12, 18, 21, 24, 27, 36, 39 ]

Before we turn to the next computations, we clean the workspace.

        gap> CleanWorkspace();

### 5.14 O+8(4)

We show that S = O+8(4) = Ω+(8,4) satisfies the following.

(a) For suitable s ∈ S of the type 2− ⊥6− (i. e., s decomposes the natural 8-dimensional module for S into an orthogonal sum of two irreducible modules of the dimensions 2 and 6, respectively) and of order 65, M(S,s) consists of exactly three pairwise nonconjugate subgroups of the type (5 ×O−6(4)).2 = (5 ×Ω−(6,4)).2.
(b) σ( S, s ) ≤ 34 817 / 1 645 056.
(c) In the extensions S.21 and S.3 of S by graph automorphisms, there is at most one maximal subgroup besides S that contains s. For the extension S.22 of S by a field automorphism, we have σ′(S.22, s) = 0. In the extension S.23 of S by the product of an involutory graph automorphism and a field automorphism, there is a unique maximal subgroup besides S that contains s.

A safe source for determining M(S,s) is [Kle87]. By inspection of the result matrix in this paper, we get that the only maximal subgroups of S that contain elements of order 65 occur in the rows 9-14 and 23-25; they have the isomorphism types S6(4) = Sp(6,4) ≅ O7(4) = Ω(7,4) and (5 ×O6−(4)).2 = (5 ×Ω−(6,4)).2, respectively, and for each of these, there are three conjugacy classes of subgroups in S, which are conjugate under the triality graph automorphism of S.
We start with the natural matrix representation of S. For convenience, we compute an isomorphic permutation group on 5 525 points.

        gap> q:= 4;;  n:= 8;;
        gap> G:= DerivedSubgroup( SO( 1, n, q ) );;
        gap> points:= NormedRowVectors( GF(q)^n );;
        gap> orbs:= Orbits( G, points, OnLines );;
        gap> List( orbs, Length );
        [ 5525, 16320 ]
        gap> hom:= ActionHomomorphism( G, orbs[1], OnLines );;
        gap> G:= Image( hom );;

The group S contains exactly six conjugacy classes of (cyclic) subgroups of order 65; this follows from the fact that the centralizer of any Sylow 13 subgroup in S has the structure 5 ×5 ×13.

        gap> Collected( Factors( Size( G ) ) );
        [ [ 2, 24 ], [ 3, 5 ], [ 5, 4 ], [ 7, 1 ], [ 13, 1 ], [ 17, 2 ] ]
        gap> ResetGlobalRandomNumberGenerators();
        gap> repeat x:= Random( G );
        >    until Order( x ) mod 13 = 0;
        gap> x:= x^( Order( x ) / 13 );;
        gap> c:= Centralizer( G, x );;
        gap> IsAbelian( c );  AbelianInvariants( c );
        true
        [ 5, 5, 13 ]

The group S6(4) contains exactly one class of subgroups of order 65, since the conjugacy classes of elements of order 65 in S6(4) are algebraically conjugate.

        gap> t:= CharacterTable( "S6(4)" );;
        gap> ord65:= PositionsProperty( OrdersClassRepresentatives( t ),
        >                               x -> x = 65 );
        [ 105, 106, 107, 108, 109, 110, 111, 112 ]
        gap> ord65 = ClassOrbit( t, ord65[1] );
        true

Thus there are at least three classes of order 65 elements in S that are not contained in S6(4) type subgroups of S. So we choose such an element s, and have to consider only overgroups of the type (5 ×Ω−(6,4)).2.
The group Ω−(6,4) ≅ U4(4) contains exactly one class of subgroups of order 65.

        gap> t:= CharacterTable( "U4(4)" );;
        gap> ords:= OrdersClassRepresentatives( t );;
        gap> ord65:= PositionsProperty( ords, x -> x = 65 );;
        gap> ord65 = ClassOrbit( t, ord65[1] );
        true

So 5 ×Ω−(6,4) contains exactly six such classes. Furthermore, subgroups in different classes are not S-conjugate.

        gap> syl5:= SylowSubgroup( c, 5 );;
        gap> elms:= Filtered( Elements( syl5 ), y -> Order( y ) = 5 );;
        gap> reps:= Set( List( elms, SmallestGeneratorPerm ) );;  Length( reps );
        6
        gap> reps65:= List( reps, y -> SubgroupNC( G, [ y * x ] ) );;
        gap> pairs:= Filtered( UnorderedTuples( [ 1 .. 6 ], 2 ),
        >                      p -> p[1] <> p[2] );;
        gap> ForAny( pairs, p -> IsConjugate( G, reps65[ p[1] ], reps65[ p[2] ] ) );
        false

We consider only subgroups M ≤ S in the three S-classes of the type (5 ×Ω−(6,4)).2.

        gap> cand:= List( reps, y -> Normalizer( G, SubgroupNC( G, [ y ] ) ) );;
        gap> cand:= Filtered( cand, y -> Size( y ) = 10 * Size( t ) );;
        gap> Length( cand );
        3

(Note that one of the members in M(S,s) is the stabilizer in S of the orthogonal decomposition 2− ⊥6−, the other two members are not reducible.)
By the above, the classes of subgroups of order 65 in each such M are in bijection with the corresponding classes in S. Since NS(〈g 〉) ⊆ M holds for any g ∈ M of order 65, also the conjugacy classes of elements of order 65 in M are in bijection with those in S.

        gap> norms:= List( reps65, y -> Normalizer( G, y ) );;
        gap> ForAll( norms, y -> ForAll( cand, M -> IsSubset( M, y ) ) );
        true

As a consequence, we have gS ∩M = gM and thus 1MS(g) = 1. This implies statement (a).
In order to show statement (b), we want to use the function `UpperBoundFixedPointRatios` introduced in Section 3.3. For that, we first compute the conjugacy classes of the three class representatives M. (Since the groups have elementary abelian Sylow 5 subgroups of the order 54, computing all conjugacy classes appears to be faster than using `ClassesOfPrimeOrder`.) Then we compute an upper bounds for σ(S,s).

        gap> syl5:= SylowSubgroup( cand[1], 5 );;
        gap> Size( syl5 );  IsElementaryAbelian( syl5 );
        625
        true
        gap> UpperBoundFixedPointRatios( G, List( cand, ConjugacyClasses ), false );
        [ 34817/1645056, false ]

Remark 1 Computing the exact value σ(S,s) in the above setup would require to test the S-conjugacy of certain order 5 elements in M. With the current GAP implementation, some of the relevant tests need several hours of CPU time.
An alternative approach would be to compute the permutation action of S on the cosets of M, of degree 6 580 224, and to count the fixed points of conjugacy class representatives of prime order. The currently available GAP library methods are not sufficient for computing this in reasonable time. "Ad-hoc code" for this special case works, but it seemed to be not appropriate to include it here.
In the proof of statement (c), again we consult the result matrix in [Kle87]. For S.3, the maximal subgroups are in the rows 4, 15, 22, 26, and 61. Only row 26 yields subgroups that contain elements s of order 65, they have the isomorphism type (5 ×GU(3,4)).2 ≅ (52 ×U3(4)).2. Note that the conjugacy classes of the members in M(S,s) are permuted by the outer automorphism of order 3, so none of the subgroups in M(S,s) extends to S.3. By [BGK08,Lemma 2.4 (2)], if there is a maximal subgroup of S.3 besides S that contains s then this subgroup is the normalizer in S.3 of the intersection of the three members of M(S,s), i. e., s is contained in at most one such subgroup.
For S.21, only the rows 9 and 23 yield maximal subgroups containing elements of order 65, and since we had chosen s in such a way that row 9 was excluded already for the simple group, only extensions of the elements in M(S,s) can appear. Exactly one of these three subgroups of S extends to S.21, so again we get just one maximal subgroup of S.21, besides S, that contains s.
All subgroups in M(S,s) extend to S.22, see [Kle87]. We compute the extensions of the above subgroups M of S to S.22, by constructing the action of the field automorphism in the permutation representation we used for S. In other words, we compute the projective action of the Frobenius map.

        gap> frob:= PermList( List( orbs[1], v -> Position( orbs[1],
        >              List( v, x -> x^2 ) ) ) );;
        gap> G2:= ClosureGroupDefault( G, frob );;
        gap> cand2:= List( cand, M -> Normalizer( G2, M ) );;
        gap> ccl:= List( cand2,
        >                M2 -> PcConjugacyClassReps( SylowSubgroup( M2, 2 ) ) );;
        gap> List( ccl, l -> Number( l, x -> Order( x ) = 2 and not x in G ) );
        [ 0, 0, 0 ]

So in each case, the extension of M to its normalizer in S.22 is non-split. This implies σ′(S.22,s) = 0.
Finally, in the extension of S by the product of a graph automorphism and the field automorphism, exactly that member of M(S,s) is invariant that is invariant under the graph automorphism, hence statement (c) holds.
It is again time to clean the workspace.

        gap> CleanWorkspace();

### 5.15 ∗ O9(3)

The group S = O9(3) = Ω9(3) is the first member in the series dealt with in [BGK08,Proposition 5.7], and serves as an example to illustrate this statement.

(a) For s ∈ S of the type 1 ⊥8− (i. e., s decomposes the natural 9-dimensional module for S into an orthogonal sum of two irreducible modules of the dimensions 1 and 8, respectively) and of order (34 + 1)/2 = 41, M(S,s) consists of one group of the type O8−(3).21 = PGO−(8,3).
(b) σ(S,s) = 1/3.
(c) The uniform spread of S is at least three, with s of order 41.

By [MSW94], the only maximal subgroup of S that contains s is the stabilizer M of the orthogonal decomposition. The group 2 ×O8−(3).21 = GO−(8,3) embeds naturally into SO(9,3), its intersection with S is PGO−(8,3). This proves statement (a).
The group M is the stabilizer of a 1-space, it has index 3 240 in S.

        gap> g:= SO( 9, 3 );;
        gap> g:= DerivedSubgroup( g );;
        gap> Size( g );
        65784756654489600
        gap> orbs:= Orbits( g, NormedRowVectors( GF(3)^9 ), OnLines );;
        gap> List( orbs, Length ) / 41;
        [ 3240/41, 81, 80 ]
        gap> Size( SO( 9, 3 ) ) / Size( GO( -1, 8, 3 ) );
        3240

So we compute the unique transitive permutation character of S that has degree 3 240.

        gap> t:= CharacterTable( "O9(3)" );;
        gap> pi:= PermChars( t, rec( torso:= [ 3240 ] ) );
        [ Character( CharacterTable( "O9(3)" ), [ 3240, 1080, 380, 132, 48, 324, 378,
              351, 0, 0, 54, 27, 54, 27, 0, 118, 0, 36, 46, 18, 12, 2, 8, 45, 0, 108,
              108, 135, 126, 0, 0, 56, 0, 0, 36, 47, 38, 27, 39, 36, 24, 12, 18, 18,
              15, 24, 2, 18, 15, 9, 0, 0, 0, 2, 0, 18, 11, 3, 9, 6, 6, 9, 6, 3, 6, 3,
              0, 6, 16, 0, 4, 6, 2, 45, 36, 0, 0, 0, 0, 0, 0, 0, 9, 9, 6, 3, 0, 0,
              15, 13, 0, 5, 7, 36, 0, 10, 0, 10, 19, 6, 15, 0, 0, 0, 0, 12, 3, 10, 0,
              3, 3, 7, 0, 6, 6, 2, 8, 0, 4, 0, 2, 0, 1, 3, 0, 0, 3, 0, 3, 2, 2, 3, 3,
              6, 2, 2, 9, 6, 3, 0, 0, 18, 9, 0, 0, 12, 0, 0, 8, 0, 6, 9, 5, 0, 0, 0,
              0, 0, 0, 0, 0, 3, 3, 3, 2, 1, 3, 3, 1, 0, 0, 4, 1, 0, 0, 1, 0, 3, 3, 1,
              1, 2, 2, 0, 0, 1, 3, 4, 0, 1, 2, 0, 0, 1, 0, 4, 1, 0, 0, 0, 0, 1, 0, 0,
              1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0 ] ) ]
        gap> spos:= Position( OrdersClassRepresentatives( t ), 41 );
        208
        gap> approx:= ApproxP( pi, spos );;
        gap> Maximum( approx );
        1/3
        gap> PositionsProperty( approx, x -> x = 1/3 );
        [ 2 ]
        gap> SizesConjugacyClasses( t )[2];
        3321
        gap> OrdersClassRepresentatives( t )[2];
        2

We see that P( S, s ) = σ( S, s ) = 1/3 holds, and that σ( g, s ) attains this maximum only for g in one class of involutions in S; let us call this class `2A`. (This class consists of the negatives of a class of reflections in GO(9,3).) This shows statement (b).
In order to show that the uniform spread of S is at least three, it suffices to show that for each triple of `2A` elements, there is an element s of order 41 in S that generates S with each element of the triple.
We work with the primitive permutation representation of S on 3 240 points. In this representation, s fixes exactly one point, and by statement (a), s generates S with x ∈ S if and only if x moves this point. Since the number of fixed points of each `2A` involution in S is exactly one third of the moved points of S, it suffices to show that we cannot choose three such involutions with mutually disjoint fixed point sets. And this is shown particularly easily because it will turn out that already for any two different `2A` involutions, the sets of fixed points of are never disjoint.
First we compute a `2A` element, which is determined as an involution with exactly 1 080 fixed points.

        gap> g:= Action( g, orbs[1], OnLines );;
        gap> repeat
        >      repeat x:= Random( g ); ord:= Order( x ); until ord mod 2 = 0;
        >      y:= x^(ord/2);
        > until NrMovedPoints( y ) = 3240 - 1080;

Next we compute the sets of fixed points of the elements in the class `2A`, by forming the S-orbit of the set of fixed points of the chosen `2A` element.

        gap> fp:= Difference( MovedPoints( g ), MovedPoints( y ) );;
        gap> orb:= Orbit( g, fp, OnSets );;

Finally, we show that for any pair of `2A` elements, their sets of fixed points intersect nontrivially. (Of course we can fix one of the two elements.) This proves statement (c).

        gap> ForAny( orb, l -> IsEmpty( Intersection( l, fp ) ) );
        false

### 5.16 O10−(3)

We show that the group S = O10−(3) = PΩ−(10,3) satisfies the following.

(a) For s ∈ S irreducible of order (35 + 1)/4 = 61, M(S,s) consists of one subgroup of the type SU(5,3) ≅ U5(3).
(b) σ(S,s) = 1/1 066.

By [Ber00], the maximal subgroups of S containing s are of extension field type, and by [KL90,Prop. 4.3.18 and 4.3.20], these groups have the structure SU(5,3) = U5(3) (which lift to 2 ×U5(3) < GU(5,3) in Ω−(10,3) = 2.S) or Ω(5,9).2, but the order of the latter group is not divisible by |s|. Furthermore, by [BGK08,Lemma 2.12 (b)], s is contained in only one member of the former class.

        gap> Size( GO(5,9) ) / 61;
        6886425600/61

(When the first version of these computations was written, the character tables of both S and U5(3) were not contained in the GAP Character Table Library, so we worked with the groups. Meanwhile the character tables are available, thus we can show also a character theoretic solution.)

        gap> t:= CharacterTable( "O10-(3)" );  s:= CharacterTable( "U5(3)" );
        CharacterTable( "O10-(3)" )
        CharacterTable( "U5(3)" )
        gap> SigmaFromMaxes( t, "61A", [ s ], [ 1 ] );
        1/1066

(Now follow the computations with groups.)
The first step is the construction of the embedding of M = SU(5,3) into the matrix group 2.S, that is, we write the matrix generators of M as linear mappings on the natural module for 2.S, and then conjugate them such that the result matrices respect the bilinear form of 2.S. For convenience, we choose a basis for the field extension F9/F3 such that the F3-linear mapping given by the invariant form of M is invariant under the F3-linear mappings given by the generators of M.

        gap> m:= SU(5,3);;
        gap> so:= SO(-1,10,3);;
        gap> omega:= DerivedSubgroup( so );;
        gap> om:= InvariantBilinearForm( so ).matrix;;
        gap> Display( om );
         . 1 . . . . . . . .
         1 . . . . . . . . .
         . . 1 . . . . . . .
         . . . 2 . . . . . .
         . . . . 2 . . . . .
         . . . . . 2 . . . .
         . . . . . . 2 . . .
         . . . . . . . 2 . .
         . . . . . . . . 2 .
         . . . . . . . . . 2
        gap> b:= Basis( GF(9), [ Z(3)^0, Z(3^2)^2 ] );
        Basis( GF(3^2), [ Z(3)^0, Z(3^2)^2 ] )
        gap> blow:= List( GeneratorsOfGroup( m ), x -> BlownUpMat( b, x ) );;
        gap> form:= BlownUpMat( b, InvariantSesquilinearForm( m ).matrix );;
        gap> ForAll( blow, x -> x * form * TransposedMat( x ) = form );
        true
        gap> Display( form );
         . . . . . . . . 1 .
         . . . . . . . . . 1
         . . . . . . 1 . . .
         . . . . . . . 1 . .
         . . . . 1 . . . . .
         . . . . . 1 . . . .
         . . 1 . . . . . . .
         . . . 1 . . . . . .
         1 . . . . . . . . .
         . 1 . . . . . . . .

The matrix `om` of the invariant bilinear form of 2.S is equivalent to the identity matrix I. So we compute matrices `T1` and `T2` that transform `om` and `form`, respectively, to ±I.

        gap> T1:= IdentityMat( 10, GF(3) );;
        gap> T1{[1..3]}{[1..3]}:= [[1,1,0],[1,-1,1],[1,-1,-1]]*Z(3)^0;;
        gap> pi:= PermutationMat( (1,10)(3,8), 10, GF(3) );;
        gap> tr:= NullMat( 10,10,GF(3) );;
        gap> tr{[1, 2]}{[1, 2]}:= [[1,1],[1,-1]]*Z(3)^0;;
        gap> tr{[3, 4]}{[3, 4]}:= [[1,1],[1,-1]]*Z(3)^0;;
        gap> tr{[7, 8]}{[7, 8]}:= [[1,1],[1,-1]]*Z(3)^0;;
        gap> tr{[9,10]}{[9,10]}:= [[1,1],[1,-1]]*Z(3)^0;;
        gap> tr{[5, 6]}{[5, 6]}:= [[1,0],[0,1]]*Z(3)^0;;
        gap> tr2:= IdentityMat( 10,GF(3) );;
        gap> tr2{[1,3]}{[1,3]}:= [[-1,1],[1,1]]*Z(3)^0;;
        gap> tr2{[7,9]}{[7,9]}:= [[-1,1],[1,1]]*Z(3)^0;;
        gap> T2:= tr2 * tr * pi;;
        gap> D:= T1^-1 * T2;;
        gap> tblow:= List( blow, x -> D * x * D^-1 );;
        gap> IsSubset( omega, tblow );
        true

Now we switch to a permutation representation of S, and use the embedding of M into 2.S to obtain the corresponding subgroup of type M in S. Then we compute an upper bound for max{ μ(g,S/M); g ∈ S× }.

        gap> orbs:= Orbits( omega, NormedRowVectors( GF(3)^10 ), OnLines );;
        gap> List( orbs, Length );
        [ 9882, 9882, 9760 ]
        gap> permgrp:= Action( omega, orbs[3], OnLines );;
        gap> M:= SubgroupNC( permgrp,
        >            List( tblow, x -> Permutation( x, orbs[3], OnLines ) ) );;
        gap> ccl:= ClassesOfPrimeOrder( M, Set( Factors( Size( M ) ) ),
        >                               TrivialSubgroup( M ) );;
        gap> UpperBoundFixedPointRatios( permgrp, [ ccl ], false );
        [ 1/1066, true ]

The entry `true` in the second position of the result indicates that in fact the exact value for the maximum of μ(g,S/M) has been computed. This implies statement (b).
We clean the workspace.

        gap> CleanWorkspace();

### 5.17 O14−(2)

We show that the group S = O14−(2) = Ω−(14,2) satisfies the following.

(a) For s ∈ S irreducible of order 27+1 = 129, M(S,s) consists of one subgroup M of the type GU(7,2) ≅ 3 ×U7(2).
(b) σ(S,s) = 1/2 015.

By [Ber00], any maximal subgroup of S containing s is of extension field type, and by [KL90,Table 3.5.F, Prop. 4.3.18], these groups have the type GU(7,2), and there is exactly one class of subgroups of this type. Furthermore, by [BGK08,Lemma 2.12 (a)], s is contained in only one member of this class.
We embed U7(2) into S, by first replacing each element in F4 by the 2 ×2 matrix of the induced F2-linear mapping w.r.t. a suitable basis, and then conjugating the images of the generators such that the invariant quadratic form of S is respected.

        gap> o:= SO(-1,14,2);;
        gap> g:= SU(7,2);;
        gap> b:= Basis( GF(4) );;
        gap> blow:= List( GeneratorsOfGroup( g ), x -> BlownUpMat( b, x ) );;
        gap> form:= NullMat( 14, 14, GF(2) );;
        gap> for i in [ 1 .. 14 ] do form[i][ 15-i ]:= Z(2); od;
        gap> ForAll( blow, x -> x * form * TransposedMat( x ) = form );
        true
        gap> pi:= PermutationMat( (1,13)(3,11)(5,9), 14, GF(2) );;
        gap> pi * form * TransposedMat( pi ) = InvariantBilinearForm( o ).matrix;
        true
        gap> pi2:= PermutationMat( (7,3)(8,4), 14, GF(2) );;
        gap> D:= pi2 * pi;;
        gap> tblow:= List( blow, x -> D * x * D^-1 );;
        gap> IsSubset( o, tblow );
        true

Note that the central subgroup of order three in GU(7,2) consists of scalar matrices.

        gap> omega:= DerivedSubgroup( o );;
        gap> IsSubset( omega, tblow );
        true
        gap> z:= Z(4) * One( g );;
        gap> tz:= D * BlownUpMat( b, z ) * D^-1;;
        gap> tz in omega;
        true

Now we switch to a permutation representation of S, and compute the conjugacy classes of prime element order in the subgroup M. The latter is done in two steps, first class representatives of the simple subgroup U7(2) of M are computed, and then they are multiplied with the scalars in M.

        gap> orbs:= Orbits( omega, NormedVectors( GF(2)^14 ), OnLines );;
        gap> List( orbs, Length );
        [ 8127, 8256 ]
        gap> omega:= Action( omega, orbs[1], OnLines );;
        gap> gens:= List( GeneratorsOfGroup( g ),
        >             x -> Permutation( D * BlownUpMat( b, x ) * D^-1, orbs[1] ) );;
        gap> g:= Group( gens );;
        gap> ccl:= ClassesOfPrimeOrder( g, Set( Factors( Size( g ) ) ),
        >                               TrivialSubgroup( g ) );;
        gap> tz:= Permutation( tz, orbs[1] );;
        gap> primereps:= List( ccl, Representative );;
        gap> Add( primereps, () );
        gap> reps:= Concatenation( List( primereps,
        >               x -> List( [ 0 .. 2 ], i -> x * tz^i ) ) );;
        gap> primereps:= Filtered( reps, x -> IsPrimeInt( Order( x ) ) );;
        gap> Length( primereps );
        48

Finally, we apply `UpperBoundFixedPointRatios` (see Section 3.3) to compute an upper bound for μ(g,S/M), for g ∈ S×.

        gap> M:= ClosureGroup( g, tz );;
        gap> bccl:= List( primereps, x -> ConjugacyClass( M, x ) );;
        gap> UpperBoundFixedPointRatios( omega, [ bccl ], false );
        [ 1/2015, true ]

Although some of the classes of M in the list `bccl` may be S-conjugate, the entry `true` in the second position of the result indicates that in fact the exact value for the maximum of μ(g,S/M), for g ∈ S×, has been computed. This implies statement (b).
We clean the workspace.

        gap> CleanWorkspace();

### 5.18 O12+(3)

We show that the group S = O12+(3) = PΩ+(12,3) satisfies the following.

(a) S has a maximal subgroup M of the type NS(PΩ+(6,9)), which has the structure PΩ+(6,9).[4].
(b) μ(g,S/M) ≤ 2/88 209 holds for all g ∈ S×.

(This result is used in the proof of [BGK08,Proposition 5.14], where it is shown that for s ∈ S of order 205, M(S,s) consists of one reducible subgroup G8 and at most two extension field type subgroups of the type NS(PΩ+(6,9)). By [GK00,Proposition 3.16], μ(g,S/G8) ≤ 19/35 holds for all g ∈ S×. This implies P(g,s) ≤ 19/35 + 2 ·2/88 209 = 6 901/88 209 < 1/3.)
Statement (a) follows from [KL90,Prop. 4.3.14].
For statement (b), we embed GO+(6,9) ≅ Ω+(6,9).22 into SO+(12,3) = 2.S.2, by replacing each element in F9 by the 2 ×2 matrix of the induced F3-linear mapping w.r.t. a suitable basis (b1, b2). We choose a basis with the property b1 = 1 and b22 = 1 + b2, because then the image of a symmetric matrix is again symmetric (so the image of the invariant form is an invariant form for the image of the group), and apply an appropriate transformation to the images of the generators.

        gap> so:= SO(+1,12,3);;
        gap> Display( InvariantBilinearForm( so ).matrix );
         . 1 . . . . . . . . . .
         1 . . . . . . . . . . .
         . . 1 . . . . . . . . .
         . . . 2 . . . . . . . .
         . . . . 2 . . . . . . .
         . . . . . 2 . . . . . .
         . . . . . . 2 . . . . .
         . . . . . . . 2 . . . .
         . . . . . . . . 2 . . .
         . . . . . . . . . 2 . .
         . . . . . . . . . . 2 .
         . . . . . . . . . . . 2
        gap> g:= GO(+1,6,9);;
        gap> Z(9)^2 = Z(3)^0 + Z(9);
        true
        gap> b:= Basis( GF(9), [ Z(3)^0, Z(9) ] );
        Basis( GF(3^2), [ Z(3)^0, Z(3^2) ] )
        gap> blow:= List( GeneratorsOfGroup( g ), x -> BlownUpMat( b, x ) );;
        gap> m:= BlownUpMat( b, InvariantBilinearForm( g ).matrix );;
        gap> Display( m );
         . . 1 . . . . . . . . .
         . . . 1 . . . . . . . .
         1 . . . . . . . . . . .
         . 1 . . . . . . . . . .
         . . . . 2 . . . . . . .
         . . . . . 2 . . . . . .
         . . . . . . 2 . . . . .
         . . . . . . . 2 . . . .
         . . . . . . . . 2 . . .
         . . . . . . . . . 2 . .
         . . . . . . . . . . 2 .
         . . . . . . . . . . . 2
        gap> pi:= PermutationMat( (2,3), 12, GF(3) );;
        gap> tr:= IdentityMat( 12, GF(3) );;
        gap> tr{[3,4]}{[3,4]}:= [[1,-1],[1,1]]*Z(3)^0;;
        gap> D:= tr * pi;;
        gap> D * m * TransposedMat( D ) = InvariantBilinearForm( so ).matrix;
        true
        gap> tblow:= List( blow, x -> D * x * D^-1 );;
        gap> IsSubset( so, tblow );
        true

The image of GO+(6,9) under the embedding into SO+(12,3) does not lie in Ω+(12,3) = 2.S, so a factor of two is missing in GO+(6,9) ∩2.S for getting (the preimage 2.M of) the required maximal subgroup M of S. Because of this, and also because currently it is time consuming to compute the derived subgroup of SO+(12,3), we work with the upward extension PSO+(12,3) = S.2. Note that M extends to a maximal subgroup of S.2.
First we factor out the centre of SO+(12,3), and switch to a permutation representation of S.2.

        gap> orbs:= Orbits( so, NormedVectors( GF(3)^12 ), OnLines );;
        gap> List( orbs, Length );
        [ 88452, 88452, 88816 ]
        gap> act:= Action( so, orbs[1], OnLines );;
        gap> SetSize( act, Size( so ) / 2 );

Next we rewrite the matrix generators for GO+(6,9) accordingly, and compute the normalizer in S.2 of the subgroup they generate; this is the maximal subgroup M.2 we need.

        gap> u:= SubgroupNC( act,
        >            List( tblow, x -> Permutation( x, orbs[1], OnLines ) ) );;
        gap> n:= Normalizer( act, u );;
        gap> Size( n ) / Size( u );
        2

Now we compute class representatives of prime order in M.2, in a smaller faithful permutation representation, and then the desired upper bound for μ(g, S/M).

        gap> norbs:= Orbits( n, MovedPoints( n ) );;
        gap> List( norbs, Length );
        [ 58968, 29484 ]
        gap> hom:= ActionHomomorphism( n, norbs[2] );;
        gap> nact:= Image( hom );;
        gap> Size( nact ) = Size( n );
        true
        gap> ccl:= ClassesOfPrimeOrder( nact, Set( Factors( Size( nact ) ) ),
        >                               TrivialSubgroup( nact ) );;
        gap> Length( ccl );
        26
        gap> preim:= List( ccl,
        >        x -> PreImagesRepresentative( hom, Representative( x ) ) );;
        gap> pccl:= List( preim, x -> ConjugacyClass( n, x ) );;
        gap> for i in [ 1 .. Length( pccl ) ] do
        >      SetSize( pccl[i], Size( ccl[i] ) );
        >    od;
        gap> UpperBoundFixedPointRatios( act, [ pccl ], false );
        [ 2/88209, true ]

Note that we have computed max{ μ(g,S.2/M.2), g ∈ S.2× } ≥ max{ μ(g,S.2/M.2), g ∈ S× } = max{ μ(g,S/M), g ∈ S× }.

### 5.19 ∗ S4(8)

We show that the group S = S4(8) = Sp(4,8) satisfies the following.

(a) For s ∈ S irreducible of order 65, M(S,s) consists of two nonconjugate subgroups of the type S2(64).2 = Sp(2,64).2 ≅ L2(64).2 ≅ O4−(8).2 = Ω−(4,8).2.
(b) σ(S,s) = 8/63.

By [Ber00], the only maximal subgroups of S that contain s are O4−(8).2 = SO−(4,8) or of extension field type. By [KL90,Prop. 4.3.10, 4.8.6], there is one class of each of these subgroups (which happen to be isomorphic).
These classes of subgroups induce different permutation characters. One argument to see this is that the involutions in the outer half of extension field type subgroup S2(64).2 < S4(8) have a two-dimensional fixed space, whereas the outer involutions in SO−(4,8) have a three-dimensional fixed space.
The former statement can be seen by using a normal basis of the field extension F64/F8, such that the action of the Frobenius automorphism (which yields a suitable outer involution) is just a double transposition on the basis vectors of the natural module for S.

        gap> sp:= SP(4,8);;
        gap> Display( InvariantBilinearForm( sp ).matrix );
         . . . 1
         . . 1 .
         . 1 . .
         1 . . .
        gap> z:= Z(64);;
        gap> f:= AsField( GF(8), GF(64) );;
        gap> repeat
        >      b:= Basis( f, [ z, z^8 ] );
        >      z:= z * Z(64);
        > until b <> fail;
        gap> sub:= SP(2,64);;
        gap> Display( InvariantBilinearForm( sub ).matrix );
         . 1
         1 .
        gap> ext:= Group( List( GeneratorsOfGroup( sub ),
        >                       x -> BlownUpMat( b, x ) ) );;
        gap> tr:= PermutationMat( (3,4), 4, GF(2) );;
        gap> conj:= ConjugateGroup( ext, tr );;
        gap> IsSubset( sp, conj );
        true
        gap> inv:= [[0,1,0,0],[1,0,0,0],[0,0,0,1],[0,0,1,0]] * Z(2);;
        gap> inv in sp;
        true
        gap> inv in conj;
        false
        gap> Length( NullspaceMat( inv - inv^0 ) );
        2

The latter statement can be shown by looking at an outer involution in SO−(4,8).

        gap> so:= SO(-1,4,8);;
        gap> der:= DerivedSubgroup( so );;
        gap> x:= First( GeneratorsOfGroup( so ), x -> not x in der );;
        gap> x:= x^( Order(x)/2 );;
        gap> Length( NullspaceMat( x - x^0 ) );
        3

The character table of L2(64).2 is currently not available in the GAP Character Table Library, so we compute the possible permutation characters with a combinatorial approach, and show statement (a).

        gap> CharacterTable( "L2(64).2" );
        fail
        gap> t:= CharacterTable( "S4(8)" );;
        gap> degree:= Size( t ) / ( 2 * Size( SL(2,64) ) );;
        gap> pi:= PermChars( t, rec( torso:= [ degree ] ) );
        [ Character( CharacterTable( "S4(8)" ), [ 2016, 0, 256, 32, 0, 36, 0, 8, 1,
              0, 4, 0, 0, 0, 28, 28, 28, 0, 0, 0, 0, 0, 0, 36, 36, 36, 0, 0, 0, 0, 0,
              0, 1, 1, 1, 0, 0, 0, 4, 4, 4, 0, 0, 0, 4, 4, 4, 0, 0, 0, 1, 1, 1, 0, 0,
              0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
              1, 1, 1, 1 ] ), Character( CharacterTable( "S4(8)" ),
            [ 2016, 256, 0, 32, 36, 0, 0, 8, 1, 4, 0, 28, 28, 28, 0, 0, 0, 0, 0, 0,
              36, 36, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 4, 4, 4, 0, 0, 0, 4, 4,
              4, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
              0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ] ) ]
        gap> spos:= Position( OrdersClassRepresentatives( t ), 65 );;
        gap> List( pi, x -> x[ spos ] );
        [ 1, 1 ]

Now we compute σ(S,s), which yields statement (b).

        gap> Maximum( ApproxP( pi, spos ) );
        8/63

We clean the workspace.

        gap> CleanWorkspace();

### 5.20 S6(2)

We show that the group S = S6(2) = Sp(6,2) satisfies the following.

(a) σ(S) = 4/7, and this value is attained exactly for σ(S,s) with s of order 9.
(b) For s ∈ S of order 9, M(S,s) consists of one subgroup of the type U4(2).2 = Ω−(6,2).2 and three conjugate subgroups of the type L2(8).3 = Sp(2,8).3.
(c) For s ∈ S of order 9, and g ∈ S×, we have P(g,s) < 1/3, except if g is in one of the classes `2A` (the transvection class) or `3A`.
(d) For s ∈ S of order 15, and g ∈ S×, we have P(g,s) < 1/3, except if g is in one of the classes `2A` or `2B`.
(e) P(S) = 11/21, and this value is attained exactly for P(S,s) with s of order 15.
(f) For all s′ ∈ S, we have P(g,s′) > 1/3 for g in at least two classes.
(g) The uniform spread of S is at least two, with s of order 9.

(Note that in this example, the optimal choice of s w.r.t. σ(S,s) is not optimal w.r.t. P(S,s).)
Statement (a) follows from the inspection of the primitive permutation characters, cf. Section 4.3.

        gap> t:= CharacterTable( "S6(2)" );;
        gap> ProbGenInfoSimple( t );
        [ "S6(2)", 4/7, 1, [ "9A" ], [ 4 ] ]

Also statement (b) follows from the information provided by the character table of S (cf. [CCN+85,p. 46]).

        gap> prim:= PrimitivePermutationCharacters( t );;
        gap> ord:= OrdersClassRepresentatives( t );;
        gap> spos:= Position( ord, 9 );;
        gap> filt:= PositionsProperty( prim, x -> x[ spos ] <> 0 );
        [ 1, 8 ]
        gap> Maxes( t ){ filt };
        [ "U4(2).2", "L2(8).3" ]
        gap> List( prim{ filt }, x -> x[ spos ] );
        [ 1, 3 ]

Now we consider statement (c). For s of order 9 and g in one of the classes `2A`, `3A`, we observe that P(g,s) = σ(g,s) holds. This is because exactly one maximal subgroup of S contains both s and g. For all other elements g, we have even σ(g,s) < 1/3.

        gap> prim:= PrimitivePermutationCharacters( t );;
        gap> spos9:= Position( ord, 9 );;
        gap> approx9:= ApproxP( prim, spos9 );;
        gap> filt9:= PositionsProperty( approx9, x -> x >= 1/3 );
        [ 2, 6 ]
        gap> AtlasClassNames( t ){ filt9 };
        [ "2A", "3A" ]
        gap> approx9{ filt9 };
        [ 4/7, 5/14 ]
        gap> List( Filtered( prim, x -> x[ spos9 ] <> 0 ), x -> x{ filt9 } );
        [ [ 16, 10 ], [ 0, 0 ] ]

Similarly, statement (d) follows. For s of order 15 and g in one of the classes `2A`, `2B`, already the degree 36 permutation character yields P(g,s) ≥ 1/3. And for all other elements g, again we have σ(g,s) < 1/3.

        gap> spos15:= Position( ord, 15 );;
        gap> approx15:= ApproxP( prim, spos15 );;
        gap> filt15:= PositionsProperty( approx15, x -> x >= 1/3 );
        [ 2, 3 ]
        gap> PositionsProperty( ApproxP( prim{ [ 2 ] }, spos15 ), x -> x >= 1/3 );
        [ 2, 3 ]
        gap> AtlasClassNames( t ){ filt15 };
        [ "2A", "2B" ]
        gap> approx15{ filt15 };
        [ 46/63, 8/21 ]

For the remaining statements, we use explicit computations with S, in the transitive degree 63 permutation representation. We start with a function that computes a transvection in Sd(2); note that the invariant bilinear form used for symplectic groups in GAP is described by a matrix with nonzero entries exactly in the positions (i,d+1−i), for 1 ≤ i ≤ d.

        gap> transvection:= function( d )
        >     local mat;
        >     mat:= IdentityMat( d, Z(2) );
        >     mat{ [ 1, d ] }{ [ 1, d ] }:= [ [ 0, 1 ], [ 1, 0 ] ] * Z(2);
        >     return mat;
        > end;;

First we compute, for statement (d), the exact values P(g,s) for g in one of the classes `2A` or `2B`, and s of order 15. Note that the classes `2A`, `2B` are the unique classes of the lengths 63 and 315, respectively.

        gap> PositionsProperty( SizesConjugacyClasses( t ), x -> x in [ 63, 315 ] );
        [ 2, 3 ]
        gap> d:= 6;;
        gap> matgrp:= Sp(d,2);;
        gap> hom:= ActionHomomorphism( matgrp, NormedRowVectors( GF(2)^d ) );;
        gap> g:= Image( hom, matgrp );;
        gap> ResetGlobalRandomNumberGenerators();
        gap> repeat s15:= Random( g );
        >    until Order( s15 ) = 15;
        gap> 2A:= Image( hom, transvection( d ) );;
        gap> Size( ConjugacyClass( g, 2A ) );
        63
        gap> IsTransitive( g, MovedPoints( g ) );
        true
        gap> RatioOfNongenerationTransPermGroup( g, 2A, s15 );
        11/21
        gap> repeat 12C:= Random( g );
        >    until Order( 12C ) = 12 and Size( Centralizer( g, 12C ) ) = 12;
        gap> 2B:= 12C^6;;
        gap> Size( ConjugacyClass( g, 2B ) );
        315
        gap> RatioOfNongenerationTransPermGroup( g, 2B, s15 );
        8/21

For statement (e), we compute P(g, s′), for a transvection g and class representatives s′ of S. It turns out that the minimum is 11/21, and it is attained for exactly one s′; by the above, this element has order 15.

        gap> ccl:= ConjugacyClasses( g );;
        gap> reps:= List( ccl, Representative );;
        gap> nongen2A:= List( reps,
        >        x -> RatioOfNongenerationTransPermGroup( g, 2A, x ) );;
        gap> min:= Minimum( nongen2A );
        11/21
        gap> Number( nongen2A, x -> x = min );
        1

For statement (f), we show that for any choice of s′, at least two of the values P(g,s′), with g in the classes `2A`, `2B`, or `3A`, are larger than 1/3.

        gap> nongen2B:= List( reps,
        >        x -> RatioOfNongenerationTransPermGroup( g, 2B, x ) );;
        gap> 3A:= s15^5;;
        gap> nongen3A:= List( reps,
        >        x -> RatioOfNongenerationTransPermGroup( g, 3A, x ) );;
        gap> bad:= List( [ 1 .. NrConjugacyClasses( t ) ],
        >                i -> Number( [ nongen2A, nongen2B, nongen3A ],
        >                             x -> x[i] > 1/3 ) );;
        gap> Minimum( bad );
        2

Finally, for statement (g), we have to consider only the case that the two elements x, y are transvections.

        gap> PositionsProperty( approx9, x -> x + approx9[2] >= 1 );
        [ 2 ]

We use the random approach described in Section 3.3.

        gap> repeat s9:= Random( g );
        >    until Order( s9 ) = 9;
        gap> RandomCheckUniformSpread( g, [ 2A, 2A ], s9, 20 );
        true

### 5.21 S8(2)

We show that the group S = S8(2) satisfies the following.

(a) For s ∈ S of order 17, M(S,s) consists of one subgroup of each of the types O8−(2).2 = Ω−(8,2).2, S4(4).2 = Sp(4,4).2, and L2(17) = PSL(2,17).
(b) For s ∈ S of order 17, and g ∈ S×, we have P(g,s) < 1/3, except if g is a transvection.
(c) The uniform spread of S is at least two, with s of order 17.

Statement (a) follows from the list of maximal subgroups of S in [CCN+85,p. 123], and the fact that 1HS(s) = 1 holds for each H ∈ M(S,s). Note that 17 divides the indices of the maximal subgroups of the types O8+(2).2 and 27 : S6(2) in S, and obviously 17 does not divide the orders of the remaining maximal subgroups.
The permutation characters induced from the first two subgroups are uniquely determined by the ordinary character tables. The permutation character induced from the last subgroup is uniquely determined if one considers also the corresponding Brauer tables; the correct class fusion is stored in the GAP Character Table Library, see [Brea].

        gap> t:= CharacterTable( "S8(2)" );;
        gap> pi1:= PossiblePermutationCharacters( CharacterTable( "O8-(2).2" ), t );;
        gap> pi2:= PossiblePermutationCharacters( CharacterTable( "S4(4).2" ), t );;
        gap> pi3:= [ TrivialCharacter( CharacterTable( "L2(17)" ) )^t ];;
        gap> prim:= Concatenation( pi1, pi2, pi3 );;
        gap> Length( prim );
        3
        gap> spos:= Position( OrdersClassRepresentatives( t ), 17 );;
        gap> List( prim, x -> x[ spos ] );
        [ 1, 1, 1 ]

For statement (b), we observe that σ(g,s) < 1/3 if g is not a transvection, and that P(g,s) = σ(g,s) for transvections g because exactly one of the three permutation characters is nonzero on both s and the class of transvections.

        gap> approx:= ApproxP( prim, spos );;
        gap> PositionsProperty( approx, x -> x >= 1/3 );
        [ 2 ]
        gap> Number( prim, pi -> pi[2] <> 0 and pi[ spos ] <> 0 );
        1
        gap> approx[2];
        8/15

In statement (c), we have to consider only the case that the two elements x, y are transvections.

        gap> PositionsProperty( approx, x -> x + approx[2] >= 1 );
        [ 2 ]

We use the random approach described in Section 3.3.

        gap> d:= 8;;
        gap> matgrp:= Sp(d,2);;
        gap> hom:= ActionHomomorphism( matgrp, NormedRowVectors( GF(2)^d ) );;
        gap> x:= Image( hom, transvection( d ) );;
        gap> g:= Image( hom, matgrp );;
        gap> C:= ConjugacyClass( g, x );;  Size( C );
        255
        gap> ResetGlobalRandomNumberGenerators();
        gap> repeat s:= Random( g );
        >    until Order( s ) = 17;
        gap> RandomCheckUniformSpread( g, [ x, x ], s, 20 );
        true

### 5.22 ∗ S10(2)

We show that the group S = S10(2) satisfies the following.

(a) For s ∈ S of order 33, M(S,s) consists of one subgroup of each of the types Ω−(10,2).2 and L2(32).5 = Sp(2,32).5.
(b) For s ∈ S of order 33, and g ∈ S×, we have P(g,s) < 1/3, except if g is a transvection.
(c) The uniform spread of S is at least two, with s of order 33.

By [Ber00], the only maximal subgroups of S that contain s have the types stated in (a), and by [KL90,Prop. 4.3.10 and 4.8.6], there is exactly one class of each of these subgroups.
We compute the values σ( g, s ), for all g ∈ S×.

        gap> t:= CharacterTable( "S10(2)" );;
        gap> pi1:= PossiblePermutationCharacters( CharacterTable( "O10-(2).2" ), t );;
        gap> pi2:= PossiblePermutationCharacters( CharacterTable( "L2(32).5" ), t );;
        gap> prim:= Concatenation( pi1, pi2 );;  Length( prim );
        2
        gap> spos:= Position( OrdersClassRepresentatives( t ), 33 );;
        gap> approx:= ApproxP( prim, spos );;

For statement (b), we observe that σ(g,s) < 1/3 if g is not a transvection, and that P(g,s) = σ(g,s) for transvections g because exactly one of the two permutation characters is nonzero on both s and the class of transvections.

        gap> PositionsProperty( approx, x -> x >= 1/3 );
        [ 2 ]
        gap> Number( prim, pi -> pi[2] <> 0 and pi[ spos ] <> 0 );
        1
        gap> approx[2];
        16/31

In statement (c), we have to consider only the case that the two elements x, y are transvections. We use the random approach described in Section 3.3.

        gap> d:= 10;;
        gap> matgrp:= Sp(d,2);;
        gap> hom:= ActionHomomorphism( matgrp, NormedRowVectors( GF(2)^d ) );;
        gap> x:= Image( hom, transvection( d ) );;
        gap> g:= Image( hom, matgrp );;
        gap> C:= ConjugacyClass( g, x );;  Size( C );
        1023
        gap> ResetGlobalRandomNumberGenerators();
        gap> repeat s:= Random( g );
        >    until Order( s ) = 33;
        gap> RandomCheckUniformSpread( g, [ x, x ], s, 20 );
        true

### 5.23 U4(2)

We show that S = U4(2) = SU(4,2) ≅ S4(3) = PSp(4,3) satisfies the following.

(a) σ(S) = 21/40, and this value is attained exactly for σ(S,s) with s of order 12.
(b) For s ∈ S of order 9, M(S,s) consists of two groups, of the types 31+2+ :2A4 = GU(3,2) and 33 :S4, respectively.
(c) P(S) = 2/5, and this value is attained exactly for P(S,s) with s of order 9.
(d) The uniform spread of S is at least three, with s of order 9.
(e) σ′(Aut(S),s) = 7/20.

(Note that in this example, the optimal choice of s w.r.t. σ(S,s) is not optimal w.r.t. P(S,s).)
Statement (a) follows from inspection of the primitive permutation characters, cf. Section 4.3.

        gap> t:= CharacterTable( "U4(2)" );;
        gap> ProbGenInfoSimple( t );
        [ "U4(2)", 21/40, 1, [ "12A" ], [ 2 ] ]

Statement (b) can be read off from the permutation characters, and the fact that the only classes of maximal subgroups that contain elements of order 9 consist of groups of the structures 31+2+:2A4 and 33:S4, see [CCN+85,p. 26].

        gap> OrdersClassRepresentatives( t );
        [ 1, 2, 2, 3, 3, 3, 3, 4, 4, 5, 6, 6, 6, 6, 6, 6, 9, 9, 12, 12 ]
        gap> prim:= PrimitivePermutationCharacters( t );
        [ Character( CharacterTable( "U4(2)" ), [ 27, 3, 7, 0, 0, 9, 0, 3, 1, 2, 0,
              0, 3, 3, 0, 1, 0, 0, 0, 0 ] ), Character( CharacterTable( "U4(2)" ),
            [ 36, 12, 8, 0, 0, 6, 3, 0, 2, 1, 0, 0, 0, 0, 3, 2, 0, 0, 0, 0 ] ),
          Character( CharacterTable( "U4(2)" ), [ 40, 8, 0, 13, 13, 4, 4, 4, 0, 0, 5,
              5, 2, 2, 2, 0, 1, 1, 1, 1 ] ), Character( CharacterTable( "U4(2)" ),
            [ 40, 16, 4, 4, 4, 1, 7, 0, 2, 0, 4, 4, 1, 1, 1, 1, 1, 1, 0, 0 ] ),
          Character( CharacterTable( "U4(2)" ), [ 45, 13, 5, 9, 9, 6, 3, 1, 1, 0, 1,
              1, 4, 4, 1, 2, 0, 0, 1, 1 ] ) ]

For statement (c), we use a primitive permutation representation on 40 points that occurs in the natural action of SU(4,2).

        gap> g:= SU(4,2);;
        gap> orbs:= Orbits( g, NormedRowVectors( GF(4)^4 ), OnLines );;
        gap> List( orbs, Length );
        [ 45, 40 ]
        gap> g:= Action( g, orbs[2], OnLines );;

First we show that for s of order 9, P(S,s) = 2/5 holds. For that, we have to consider only P(g,s), with g in one of the classes `2A` (of length 45) and `3A` (of length 40); since the class `3B` contains the inverses of the elements in the class `3A`, we need not test it.

        gap> spos:= Position( OrdersClassRepresentatives( t ), 9 );
        17
        gap> approx:= ApproxP( prim, spos );
        [ 0, 3/5, 1/10, 17/40, 17/40, 1/8, 11/40, 1/10, 1/20, 0, 9/40, 9/40, 3/40,
          3/40, 3/40, 1/40, 1/20, 1/20, 1/40, 1/40 ]
        gap> badpos:= PositionsProperty( approx, x -> x >= 2/5 );
        [ 2, 4, 5 ]
        gap> PowerMap( t, 2 )[4];
        5
        gap> OrdersClassRepresentatives( t );
        [ 1, 2, 2, 3, 3, 3, 3, 4, 4, 5, 6, 6, 6, 6, 6, 6, 9, 9, 12, 12 ]
        gap> SizesConjugacyClasses( t );
        [ 1, 45, 270, 40, 40, 240, 480, 540, 3240, 5184, 360, 360, 720, 720, 1440,
          2160, 2880, 2880, 2160, 2160 ]

A representative g of a class of length 40 can be found as the third power of any order 9 element.

        gap> PowerMap( t, 3 )[ spos ];
        4
        gap> ResetGlobalRandomNumberGenerators();
        gap> repeat s:= Random( g );
        >    until Order( s ) = 9;
        gap> Size( ConjugacyClass( g, s^3 ) );
        40
        gap> prop:= RatioOfNongenerationTransPermGroup( g, s^3, s );
        13/40

Next we examine g in the class `2A`.

        gap> repeat x:= Random( g ); until Order( x ) = 12;
        gap> Size( ConjugacyClass( g, x^6 ) );
        45
        gap> prop:= RatioOfNongenerationTransPermGroup( g, x^6, s );
        2/5

Finally, we compute that for s of order different from 9 and g in the class `2A`, P(g,s) is larger than 2/5.

        gap> ccl:= List( ConjugacyClasses( g ), Representative );;
        gap> SortParallel( List( ccl, Order ), ccl );
        gap> List( ccl, Order );
        [ 1, 2, 2, 3, 3, 3, 3, 4, 4, 5, 6, 6, 6, 6, 6, 6, 9, 9, 12, 12 ]
        gap> prop:= List( ccl, r -> RatioOfNongenerationTransPermGroup( g, x^6, r ) );
        [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 5/9, 1, 1, 1, 1, 1, 1, 2/5, 2/5, 7/15, 7/15 ]
        gap> Minimum( prop );
        2/5

In order to show statement (d), we have to consider triples (x1, x2, x3) with xi of prime order and ∑i=13 P(xi,s) ≥ 1. This means that it suffices to check x in the class `2A`, y in `2` `A` ∪`3` `A`, and z in `2` `A` ∪`3` `A` ∪`3` `D`.

        gap> approx[2]:= 2/5;;
        gap> approx[4]:= 13/40;;
        gap> primeord:= PositionsProperty( OrdersClassRepresentatives( t ),
        >                                  IsPrimeInt );
        [ 2, 3, 4, 5, 6, 7, 10 ]
        gap> RemoveSet( primeord, 5 );
        gap> primeord;
        [ 2, 3, 4, 6, 7, 10 ]
        gap> approx{ primeord };
        [ 2/5, 1/10, 13/40, 1/8, 11/40, 0 ]
        gap> AtlasClassNames( t ){ primeord };
        [ "2A", "2B", "3A", "3C", "3D", "5A" ]
        gap> triples:= Filtered( UnorderedTuples( primeord, 3 ),
        >                  t -> Sum( approx{ t } ) >= 1 );
        [ [ 2, 2, 2 ], [ 2, 2, 4 ], [ 2, 2, 7 ], [ 2, 4, 4 ], [ 2, 4, 7 ] ]

We use the random approach described in Section 3.3.

        gap> repeat 6E:= Random( g );
        >    until Order( 6E ) = 6 and Size( Centralizer( g, 6E ) ) = 18;
        gap> 2A:= 6E^3;;
        gap> 3A:= s^3;;
        gap> 3D:= 6E^2;;
        gap> RandomCheckUniformSpread( g, [ 2A, 2A, 2A ], s, 50 );
        true
        gap> RandomCheckUniformSpread( g, [ 2A, 2A, 3A ], s, 50 );
        true
        gap> RandomCheckUniformSpread( g, [ 3D, 2A, 2A ], s, 50 );
        true
        gap> RandomCheckUniformSpread( g, [ 2A, 3A, 3A ], s, 50 );
        true
        gap> RandomCheckUniformSpread( g, [ 3D, 3A, 2A ], s, 50 );
        true

Statement (e) can be proved using `ProbGenInfoAlmostSimple`, cf. Section 4.4.

        gap> t:= CharacterTable( "U4(2)" );;
        gap> t2:= CharacterTable( "U4(2).2" );;
        gap> spos:= PositionsProperty( OrdersClassRepresentatives( t ), x -> x = 9 );;
        gap> ProbGenInfoAlmostSimple( t, t2, spos );
        [ "U4(2).2", 7/20, [ "9AB" ], [ 2 ] ]

### 5.24 U4(3)

We show that S = U4(3) = PSU(4,3) satisfies the following.

(a) σ(S) = 53/153, and this value is attained exactly for σ(S,s) with s of order 7.
(b) For s ∈ S of order 7, M(S,s) consists of two nonconjugate groups of the type L3(4), one group of the type U3(3), and four pairwise nonconjugate groups of the type A7.
(c) P(S) = 43/135, and this value is attained exactly for P(S,s) with s of order 7.
(d) The uniform spread of S is at least three, with s of order 7.
(e) The preimage of s in the matrix group SU(4,3) ≅ 4.U4(3) has order 28, the preimages of the groups in M(S,s) have the structures 42.L3(4), 4 ×U3(3) ≅ GU(3,3), and 4.A7 (the latter being a central product of a cyclic group of order four and 2.A7).
(f) P′(S.21,s) = 13/27, σ′(S.22) = 1/3, and σ′(S.23) = 31/162, with s of order 7 in each case.

Statement (a) follows from inspection of the primitive permutation characters, cf. Section 4.3.

        gap> t:= CharacterTable( "U4(3)" );;
        gap> ProbGenInfoSimple( t );
        [ "U4(3)", 53/135, 2, [ "7A" ], [ 7 ] ]

Statement (b) can be read off from the permutation characters, and the fact that the only classes of maximal subgroups that contain elements of order 7 consist of groups of the structures as claimed, see [CCN+85,p. 52].

        gap> prim:= PrimitivePermutationCharacters( t );;
        gap> spos:= Position( OrdersClassRepresentatives( t ), 7 );
        13
        gap> List( Filtered( prim, x -> x[ spos ] <> 0 ), l -> l{ [ 1, spos ] } );
        [ [ 162, 1 ], [ 162, 1 ], [ 540, 1 ], [ 1296, 1 ], [ 1296, 1 ], [ 1296, 1 ],
          [ 1296, 1 ] ]

In order to show statement (c) (which then implies statement (d)), we use a permutation representation on 112 points. It corresponds to an orbit of one-dimensional subspaces in the natural module of Ω−(6,3) ≅ S.

        gap> matgrp:= DerivedSubgroup( SO( -1, 6, 3 ) );;
        gap> orbs:= Orbits( matgrp, NormedRowVectors( GF(3)^6 ), OnLines );;
        gap> List( orbs, Length );
        [ 126, 126, 112 ]
        gap> G:= Action( matgrp, orbs[3], OnLines );;

It is sufficient to compute P(g,s), for involutions g ∈ S.

        gap> approx:= ApproxP( prim, spos );
        [ 0, 53/135, 1/10, 1/24, 1/24, 7/45, 4/45, 1/27, 1/36, 1/90, 1/216, 1/216,
          7/405, 7/405, 1/270, 0, 0, 0, 0, 1/270 ]
        gap> Filtered( approx, x -> x >= 43/135 );
        [ 53/135 ]
        gap> OrdersClassRepresentatives( t );
        [ 1, 2, 3, 3, 3, 3, 4, 4, 5, 6, 6, 6, 7, 7, 8, 9, 9, 9, 9, 12 ]
        gap> ResetGlobalRandomNumberGenerators();
        gap> repeat g:= Random( G ); until Order(g) = 2;
        gap> repeat s:= Random( G );
        >    until Order(s) = 7;
        gap> bad:= RatioOfNongenerationTransPermGroup( G, g, s );
        43/135
        gap> bad < 1/3;
        true

Statement (e) can be shown easily with character-theoretic methods, as follows. Since SU(4,3) is a Schur cover of S and the groups in M(S,s) are simple, only very few possibilities have to be checked. The Schur multiplier of U3(3) is trivial (see, e. g., [CCN+85,p. 14]), so the preimage in SU(4,3) is a direct product of U3(3) and the centre of SU(4,3). Neither L3(4) nor its double cover 2.L3(4) can be a subgroup of SU(4,3), so the preimage of L3(4) must be a Schur cover of L3(4), i. e., it must have either the type 41.L3(4) or 42.L3(4) (see [CCN+85,p. 23]); only the type 42.L3(4) turns out to be possible.

        gap> 4t:= CharacterTable( "4.U4(3)" );;
        gap> Length( PossibleClassFusions( CharacterTable( "L3(4)" ), 4t ) );
        0
        gap> Length( PossibleClassFusions( CharacterTable( "2.L3(4)" ), 4t ) );
        0
        gap> Length( PossibleClassFusions( CharacterTable( "4_1.L3(4)" ), 4t ) );
        0
        gap> Length( PossibleClassFusions( CharacterTable( "4_2.L3(4)" ), 4t ) );
        4

As for the preimage of the A7 type subgroups, we first observe that the double cover of A7 cannot be a subgroup of the double cover of S, so the preimage of A7 in the double cover of U4(3) is a direct product 2 ×A7. The group SU(4,3) does not contain A7 type subgroups, thus the A7 type subgroups in 2.U4(3) lift to double covers of A7 in SU(4,3). This proves the claimed structure.

        gap> 2t:= CharacterTable( "2.U4(3)" );;
        gap> Length( PossibleClassFusions( CharacterTable( "2.A7" ), 2t ) );
        0
        gap> Length( PossibleClassFusions( CharacterTable( "A7" ), 4t ) );
        0

For statement (f), we consider automorphic extensions of S. The bound for S.23 has been computed in Section 4.4. That for S.22 can be computed form the fact that the classes of maximal subgroups of S.22 containing s of order 7 are S, one class of U3(3).2 type subgroups, and two classes of S7 type subgroups which induce the same permutation character (see [CCN+85,p. 52]).

        gap> t2:= CharacterTable( "U4(3).2_2" );;
        gap> pi1:= PossiblePermutationCharacters( CharacterTable( "U3(3).2" ), t2 );
        [ Character( CharacterTable( "U4(3).2_2" ), [ 540, 12, 54, 0, 0, 9, 8, 0, 0,
              6, 0, 0, 1, 2, 0, 0, 0, 2, 0, 24, 4, 0, 0, 0, 0, 0, 0, 3, 2, 0, 4, 0,
              0, 0 ] ) ]
        gap> pi2:= PossiblePermutationCharacters( CharacterTable( "A7.2" ), t2 );
        [ Character( CharacterTable( "U4(3).2_2" ), [ 1296, 48, 0, 27, 0, 9, 0, 4, 1,
              0, 3, 0, 1, 0, 0, 0, 0, 0, 216, 24, 0, 4, 0, 0, 0, 9, 0, 3, 0, 1, 0, 1,
              0, 0 ] ) ]
        gap> prim:= Concatenation( pi1, pi2, pi2 );;
        gap> outer:= Difference(
        >      PositionsProperty( OrdersClassRepresentatives( t2 ), IsPrimeInt ),
        >      ClassPositionsOfDerivedSubgroup( t2 ) );;
        gap> spos:= Position( OrdersClassRepresentatives( t2 ), 7 );;
        gap> Maximum( ApproxP( prim, spos ){ outer } );
        1/3

Finally, Section 4.4 shows that the character tables are not sufficient for what we need, so we compute the exact proportion of nongeneration for U4(3).21 ≅ SO−(6,3).

        gap> matgrp:= SO( -1, 6, 3 );
        SO(-1,6,3)
        gap> orbs:= Orbits( matgrp, NormedRowVectors( GF(3)^6 ), OnLines );;
        gap> List( orbs, Length );
        [ 126, 126, 112 ]
        gap> G:= Action( matgrp, orbs[3], OnLines );;
        gap> repeat s:= Random( G );
        >    until Order( s ) = 7;
        gap> repeat
        >      repeat 2B:= Random( G ); until Order( 2B ) mod 2 = 0;
        >      2B:= 2B^( Order( 2B ) / 2 );
        >      c:= Centralizer( G, 2B );
        >    until Size( c ) = 12096;
        gap> RatioOfNongenerationTransPermGroup( G, 2B, s );
        13/27
        gap> repeat
        >      repeat 2C:= Random( G ); until Order( 2C ) mod 2 = 0;
        >      2C:= 2C^( Order( 2C ) / 2 );
        >      c:= Centralizer( G, 2C );
        >    until Size( c ) = 1440;
        gap> RatioOfNongenerationTransPermGroup( G, 2C, s );
        0

### 5.25 U6(3)

We show that S = U6(3) = PSU(6,3) satisfies the following.

(a) For s ∈ S of the type 1 ⊥5 (i. e., the preimage of s in 2.S = SU(6,3) decomposes the natural 6-dimensional module for 2.S into an orthogonal sum of two irreducible modules of the dimensions 1 and 5, respectively) and of order (35 + 1)/2 = 122, M(S,s) consists of one group of the type 2 ×U5(3), which lifts to a subgroup of the type 4 ×U5(3) = GU(5,3) in 2.S. (The preimage of s in 2.S has order 35 + 1 = 244.)
(b) σ(S,s) = 353/3 159.

By [MSW94], the only maximal subgroup of S that contains s is the stabilizer H ≅ 2 ×U5(3) of the orthogonal decomposition. This proves statement (a).
The character table of S is currently not available in the GAP Character Table Library. We consider the permutation action of S on the orbit of the stabilized 1-space. So M can be taken as a point stabilizer in this action.

        gap> CharacterTable( "U6(3)" );
        fail
        gap> g:= SU(6,3);;
        gap> orbs:= Orbits( g, NormedRowVectors( GF(9)^6 ), OnLines );;
        gap> List( orbs, Length );
        [ 22204, 44226 ]
        gap> repeat x:= PseudoRandom( g ); until Order( x ) = 244;
        gap> List( orbs, o -> Number( o, v -> OnLines( v, x ) = v ) );
        [ 0, 1 ]
        gap> g:= Action( g, orbs[2], OnLines );;
        gap> M:= Stabilizer( g, 1 );;

Then we compute a list of elements in M that covers the conjugacy classes of prime element order, from which the numbers of fixed points and thus max{ μ( S/M, g ); g ∈ M× } = σ( S, s ) can be derived. This way we avoid completely to check the S-conjugacy of elements (class representatives of Sylow subgroups in M).

        gap> elms:= [];;
        gap> for p in Set( Factors( Size( M ) ) ) do
        >      syl:= SylowSubgroup( M, p );
        >      Append( elms, Filtered( PcConjugacyClassReps( syl ),
        >                              r -> Order( r ) = p ) );
        >    od;
        gap> 1 - Minimum( List( elms, NrMovedPoints ) ) / Length( orbs[2] );
        353/3159

### 5.26 U8(2)

We show that S = U8(2) = SU(8,2) satisfies the following.

(a) For s ∈ S of the type 1 ⊥7 (i. e., s decomposes the natural 8-dimensional module for S into an orthogonal sum of two irreducible modules of the dimensions 1 and 7, respectively) and of order 27 + 1 = 129, M(S,s) consists of one group of the type 3 ×U7(2) = GU(7,2).
(b) σ(S,s) = 2 753/10 880.

By [MSW94], the only maximal subgroup of S that contains s is the stabilizer M ≅ GU(7,2) of the orthogonal decomposition. This proves statement (a).
The character table of S is currently not available in the GAP Character Table Library. We proceed exactly as in Section 5.25 in order to prove statement (b).

        gap> CharacterTable( "U8(2)" );
        fail
        gap> g:= SU(8,2);;
        gap> orbs:= Orbits( g, NormedRowVectors( GF(4)^8 ), OnLines );;
        gap> List( orbs, Length );
        [ 10965, 10880 ]
        gap> repeat x:= PseudoRandom( g ); until Order( x ) = 129;
        gap> List( orbs, o -> Number( o, v -> OnLines( v, x ) = v ) );
        [ 0, 1 ]
        gap> g:= Action( g, orbs[2], OnLines );;
        gap> M:= Stabilizer( g, 1 );;
        gap> elms:= [];;
        gap> for p in Set( Factors( Size( M ) ) ) do
        >      syl:= SylowSubgroup( M, p );
        >      Append( elms, Filtered( PcConjugacyClassReps( syl ),
        >                              r -> Order( r ) = p ) );
        >    od;
        gap> Length( elms );
        611
        gap> 1 - Minimum( List( elms, NrMovedPoints ) ) / Length( orbs[2] );
        2753/10880

## References

[Ber00]
  'A. Bereczky, Maximal overgroups of Singer elements in classical groups, J. Algebra 234 (2000), no. 1, 187-206. MR 1799483 (2002a:20049)
[BGK08]
  T. Breuer, R. M. Guralnick, and W. M. Kantor, Probabilistic generation of finite simple groups, II, J. Algebra 320 (2008), no. 2, 443-494. MR 2422303 (2010e:20096)
[BP98]
  T. Breuer and G. Pfeiffer, Finding possible permutation characters, J. Symbolic Comput. 26 (1998), no. 3, 343-354. MR 1633876 (99e:20005)
[Brea]
  T. Breuer, Ambiguous class fusions in the GAP character table library, `http://www.math.rwth-aachen.de/` ``~`Thomas.Breuer/` `ctbllib/``doc/` `ambigfus.pdf`.
[Breb]

  , Using table automorphisms for constructing character tables in GAP, `http://www.math.rwth-aachen.de/` ``~`Thomas.Breuer/` `ctbllib/``doc/` `ctblcons.pdf`.
[Bre12]

  , The GAP Character Table Library, Version 1.2, `http://www.math.rwth-aachen.de/` ``~`Thomas.Breuer/` `ctbllib`, Mar 2012, GAP package.
[BW75]
  J. L. Brenner and J. Wiegold, Two-generator groups. I, Michigan Math. J. 22 (1975), 53-64. MR 0372033 (51 #8250)
[CCN+85]
  J. H. Conway, R. T. Curtis, S. P. Norton, R. A. Parker, and R. A. Wilson, Atlas of finite groups, Oxford University Press, Eynsham, 1985, Maximal subgroups and ordinary characters for simple groups, With computational assistance from J. G. Thackray. MR 827219 (88g:20025)
[GAP12]
  GAP - Groups, Algorithms, and Programming, Version 4.5.0, `http://www.gap-system.org`, Apr 2012.
[GK00]
  R. M. Guralnick and W. M. Kantor, Probabilistic generation of finite simple groups, J. Algebra 234 (2000), no. 2, 743-792, Special issue in honor of Helmut Wielandt. MR 1800754 (2002f:20038)
[GM01]
  S. Ganief and J. Moori, On the spread of the sporadic simple groups, Comm. Algebra 29 (2001), no. 8, 3239-3255. MR 1849484 (2002i:20025)
[GPPS99]
  R. Guralnick, T. Penttila, C. E. Praeger, and J. Saxl, Linear groups with orders having certain large prime divisors, Proc. London Math. Soc. 78 (1999), no. 1, 167-214. MR 1658168 (99m:20113)
[Hul05]
  A. Hulpke, Constructing transitive permutation groups, J. Symbolic Comput. 39 (2005), no. 1, 1-30. MR 2168238 (2006e:20004)
[HW04]
  P. E. Holmes and R. A. Wilson, PSL2(59) is a subgroup of the Monster, J. London Math. Soc. 69 (2004), no. 1, 141-152. MR 2025332 (2004k:20035)
[KL90]
  P. Kleidman and M. Liebeck, The subgroup structure of the finite classical groups, London Mathematical Society Lecture Note Series, vol. 129, Cambridge University Press, Cambridge, 1990. MR 1057341 (91g:20001)
[Kle87]
  P. B. Kleidman, The maximal subgroups of the finite 8-dimensional orthogonal groups PΩ+8(q) and of their automorphism groups, J. Algebra 110 (1987), no. 1, 173-242. MR 904187 (88i:20070)
[MSW94]
  G. Malle, J. Saxl, and T. Weigel, Generation of classical groups, Geom. Dedicata 49 (1994), no. 1, 85-116. MR 1261575 (95c:20068)
[Wil99]
  R. A. Wilson, The maximal subgroups of the Baby Monster. I, J. Algebra 211 (1999), no. 1, 1-14. MR 1656568 (2000b:20016)
[WPN+11]
  R. A. Wilson, R. A. Parker, S. Nickerson, J. N. Bray, and T. Breuer, AtlasRep, a GAP Interface to the Atlas of Group Representations, Version 1.5, `http://www.math.rwth-aachen.de/` ``~`Thomas.Breuer/` `atlasrep`, Jul 2011, Refereed GAP package.
[WWT+]
  R. A. Wilson, P. Walsh, J. Tripp, I. Suleiman, R. A. Parker, S. P. Norton, S. Nickerson, S. Linton, J. Bray, and R. Abbott, ATLAS of Finite Group Representations, `http://brauer.maths.qmul.ac.uk/` `Atlas/`.

File translated from TEX by TTH, version 3.59.
On 5 May 2012, 09:07.