Atlas Data for the Sporadic Groups#

Most of the functions described here use data derived from the Web Atlas. The data has been prepared for inclusion in Magma by Michael Downward and Eamonn O’Brien. It maintains Atlas names, conventions and orderings.

All of these functions, except GoodBasePoints, accept as input matrix or permutation groups. The algorithm underpinning GoodBasePoints due to O’Brien & Wilson [O'Brien and Wilson, 2005].

StandardGenerators(G, str : parameters): Grp, MonStgElt -> BoolElt, SeqEnum, SeqEnum#

Projective       : BoolElt                    Default: false
AutomorphismGroup: BoolElt                    Default: false

Construct standard generators for small quasisimple or sporadic group \(G\) having name str; words in SLP group defined on the defining generators of \(G\) are also obtained for the standard generators.

If \(G\) is sporadic and AutomorphismGroup is true, assume \(G\) is automorphism group of group having name str.

If standard generators found, return true and sequences of generators and corresponding words, else false.

Note: A return value of false only means that the algorithm’s random search for standard generators did not succeed within the number of tries allowed. If the user is sure the group \(G\) matches the name str, then they should try the function again.

If \(G\) is absolutely irreducible matrix group and Projective is true, then construct standard generators possibly modulo centre of \(G\).

This function currently works for all sporadic simple groups and all quasisimple groups for which the simple quotient has order at most \(2 \times 10^8\). If you call it with an invalid value of str, then it will print out a list of all valid values.

StandardGeneratorsGroupNames() -> SetIndx#: A list of valid strings for the second argument of StandardGenerators.

StandardCopy(str): MonStgElt -> Grp, BoolElt#: The standard copy of the group \(G\) having the name str. If the second return value is true, then the group \(H\) returned is a matrix group with nontrivial scalar subgroup \(Z\), and it is \(H/Z\) rather than \(H\) that is isomorphic to \(G\).

IsomorphismToStandardCopy(G, str : parameters): Grp, MonStgElt -> BoolElt, Map#

Projective       : BoolElt                    Default: false
AutomorphismGroup: BoolElt                    Default: false

Use the StandardGenerators function to construct a (possibly projective) isomorphism from \(G\) to a standard copy of \(G\). Options as for StandardGenerators. The first returned value indicates whether the call of StandardGenerators was successful.

StandardPresentation(G, str : parameters): Grp, MonStgElt -> BoolElt, SeqEnum, SeqEnum#

Projective       : BoolElt                    Default: false
Generators       : SeqEnum                    Default: []
AutomorphismGroup: BoolElt                    Default: false

Return true if standard presentation is satisfied by generators of sporadic group \(G\) having name str, else false.

If AutomorphismGroup is true, assume \(G\) is automorphism group of sporadic group having name str.

Standard generators may be supplied as Generators, otherwise defining generators are assumed to be standard.

If \(G\) is absolutely irreducible matrix group and Projective is true, then verify presentation modulo centre of \(G\).

MaximalSubgroups(G, str : parameters): Grp, MonStgElt -> BoolElt, SeqEnum, SeqEnum#

Projective       : BoolElt                    Default: false
Generators       : SeqEnum                    Default: []
AutomorphismGroup: BoolElt                    Default: false

Construct some maximal subgroups for sporadic group \(G\) having name str. If AutomorphismGroup is true, assume \(G\) is automorphism group of sporadic group having name str and construct some of its maximal subgroups.

If standard generators supplied as Generators or found for \(G\) then return true and list of subgroups, else return false.

If \(G\) is absolutely irreducible matrix group and Projective is true, then construct standard generators and so subgroups possibly modulo centre of G.

Subgroups(G, str : parameters): Grp, MonStgElt -> BoolElt, SeqEnum#

Projective: BoolElt                    Default: false
Generators: SeqEnum                    Default: []

Construct certain subgroups for sporadic group \(G\) having name str. If standard generators supplied as Generators or found for \(G\) then return true and list of subgroups, else return false.

If \(G\) is absolutely irreducible matrix group and Projective is true, then construct standard generators possibly modulo centre of \(G\).

GoodBasePoints(G, str : parameters): Grp, MonStgElt -> BoolElt, SeqEnum#

Projective: BoolElt                    Default: false
Generators: SeqEnum                    Default: []

If standard generators supplied as Generators or found for sporadic group \(G\) having name str, then return true and list of base points for \(G\), else return false.

If \(G\) is absolutely irreducible and Projective is true, then standard generators are possibly modulo centre of \(G\), and base points are correspondingly adjusted.

SubgroupsData(str): MonStgElt -> SeqEnum#: Display stored subgroup data for sporadic group having name str.

MaximalSubgroupsData(str : parameters): MonStgElt -> SeqEnum#

AutomorphismGroup: BoolElt                    Default: false

Display stored data for some maximal subgroups of sporadic group having name str. If AutomorphismGroup is true, then display stored data for some maximal subgroups of automorphism group of sporadic group.

Example: Sporadic J1 (ex-328794)#

The machinery is illustrated in the case of the sporadic Janko group \(J_1\).

> G :=
> MatrixGroup<7, GF(11) |
> [ 9, 1, 1, 3, 1, 3, 3, 1, 1, 3, 1, 3, 3, 9, 1, 3, 1, 3, 3, 9, 1, 3, 1, 3,
>  3, 9, 1, 1, 1, 3, 3, 9, 1, 1, 3, 3, 3, 9, 1, 1, 3, 1, 3, 9, 1, 1, 3, 1, 3 ],
> [ 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0,
> 0, 1, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 10, 10, 0, 0, 0, 0, 0,0] >;
> flag, S := StandardGenerators (G, "J1");
> flag;
true
> StandardPresentation (G, "J1": Generators := S);
true
> flag, M:= MaximalSubgroups (G, "J1": Generators := S);
> #M;
7
> M[4];
rec<recformat<name: MonStgElt, parent: MonStgElt, generators: SeqEnum,
 group: Grp, order: RngIntElt, index: RngIntElt> |
     name := 19:6,
     parent := J1,
     group := MatrixGroup(7, GF(11))
     Generators:
         [ 0  1  4  3  3  4  7]
         [ 1  2  8  3  6  2  9]
         [ 4  8 10  1  6  0  9]
         [ 3  3  1  8  9  1 10]
         [ 3  6  6  9  1  3  7]
         [ 4  2  0  1  3  0  9]
         [ 7  9  9 10  7  9  0]

         [ 4  6  2  3  8  1  6]
         [ 8  1  3 10  2  7  4]
         [ 3  6  1  0  6  9  6]
         [ 2  3  6  9  0  3  7]
         [ 7  8  5  2  4  6  4]
         [10  4  5  2  8  6  8]
         [10  9  0  1  9  8  9],
     order := 114,
     index := 1540
     >

Run in calculator