# Database of Almost-Simple Groups

Magma includes a database containing information about almost simple groups $G$, where $S \leq G \leq {\operatorname{Aut}}(S)$ and $S$ is a simple group of small order. The $G$ that are included in the database are those associated with $S$ such that $|S|$ is less than 16000000, as well as $M_{24}$, $HS$, $J_3$, $McL$, $Sz(32)$ and $L_6(2)$.

The information stored here is primarily for use in computing maximal subgroups and automorphism groups. The database was originally conceived by Derek Holt, with a major extension by Volker Gebhardt and sporadic additions by Bill Unger. The implementation is by Bruce Cox.

It is possible to request the $i$-th entry of the database. Alternatively, and more usefully, one can supply three integers: the order $o1$ of $S$, the order $o2$ of $G$ and the sum $k$ of the orders of the class representatives of $G$. The last of these can be expensive to compute; however, knowledge of the classes is helpful to benefit from the information stored in the entry. Of course, if the entry is beyond the range of the database, then it is a wasted computation—the intrinsics `ExistsGroupData` and `NumberOfGroups` are provided to determine from the orders whether this is the case.

## The Record Fields

The result returned by the `GroupData` function is a record with a number of fields containing information about the almost simple group and its socle. This information includes information used to compute automorphisms and maximal subgroups of the almost simple group by these Magma functions. The following describes these fields. The groups $G$ and $S$ are as above the almost simple group $G$ and its socle, the simple group $S$. Let $A$ be the full automorphism group of $S$, and let $F\langle x,y\rangle$ be a free group on two generators, called $x$ and $y$.

First comes information about $S$. Each $S$ is two generated, by $x$ and $y$ as above, say.

Field `resname`: A string giving a name to the simple group $S$. ($S$ is the soluble residual of $G$).

Field `resorder`: The order of $S$ as an integer.

Field `geninfo`: Information on where to find $x$ and $y$ in $S$. This is a sequence of two tuples, each with 3 entries. The first gives a generator order, the second the length of its conjugacy class, and the third the probability of picking the right generator given the previous information. The first tuple’s order/length information always uniquely defines one conjugacy class of the group $S$ and has probability 1, so $x$ is easy to find.

Field `rels`: A sequence of words in $F$ which, taken together with the generator orders from `geninfo`, form a presentation for $S$ on $x$ and $y$.

Field `permrep`: A permutation representation of the full automorphism group of $S$. The first two generators are $x$ and $y$, followed by outer generators. In what follows the outer generators are called $t$, $u$, $v$.

Field `outimages` A sequence of sequences of words in $F$. These give the images of $x$ and $y$ under the generators of the outer automorphism group of $S$.

Field `order`: An integer, the order of $G$.

Field `inv`: The invariant used to separate non-isomorphic $\langle |S|,|G|\rangle$ possibilities. An integer, it is the sum over the classes of $G$ of the order of the elements in each class.

Field `name`: A name for $G$ as a string.

Field `conjelts`: If $G$ is not normal in the automorphism group, these words are coset representatives of the normaliser of $G$ in $A$ as words in $t$, $u$, $v$.

Field `subgens`: Words in $t$, $u$, $v$ that, together with $x$ and $y$, generate $G$.

Field `subpres`: A presentation of $G/S$ on `subgens`. Note: If $G=S$ then `subgens` will be the empty sequence, but `subpres` will be the trivial FP-group with one generator.

Field `normgens`: Words in $t$, $u$, $v$ that generate the outer automorphism group of $G$.

Field `normpres`: A presentation of the outer automorphism group of $G$ on `normgens`. Again, if $A=G$ then `normgens` will be the empty sequence, but `normpres` will be the trivial FP-group with one generator.

Field `maxsubints`: A sequence of records describing the intersections of the maximal subgroups of $G$ that do not contain $S$ with $S$. Each record gives the order of the intersection, its class length in $S$, generators as words in $x$ and $y$, and a presentation on these generators.

## Creating the Database

### `AlmostSimpleGroupDatabase() -> DB`

This function returns a database object which contains information about the database.

## Accessing the Database

### `# D: DB -> RngIntElt`

Returns the number of entries stored in the database.

### `GroupData(D, i): DB, RngIntElt -> Rec`

### `GroupData(D, o1, o2, k): DB, RngIntElt, RngIntElt, RngIntElt -> Rec`

Returns the specified entry from the database $D$ as a record. The first form gives the $i$th entry of the database. The second form gives information on an almost simple group of order $o2$, with socle of order $o1$. The value of $k$ should be as explained in `inv` above.

### `ExistsGroupData(D, o1, o2): DB, RngIntElt, RngIntElt -> BoolElt`

### `ExistsGroupData(D, o1, o2, i): DB, RngIntElt, RngIntElt, RngIntElt -> BoolElt, Rec`

Returns whether any record exists for a simple group of order $o1$ and a supergroup $G$ of order $o2$ lying within its automorphism group. In the second form an invariant, $i$ as described above, is also supplied, and the result is true if there is a record in the database with the given orders and invariant, and false otherwise. When the result is true, the corresponding record is also returned.

### `NumberOfGroups(D, o1, o2): DB, RngIntElt, RngIntElt -> RngIntElt, RngIntElt`

Returns the number of records in the database $D$ corresponding to a simple group of order $o1$ and a supergroup $G$ of order $o2$ lying within its automorphism group. The second return value gives the index of the first such record, if there is one. (This is most useful when the first return value is 1.) If the return values are $d$ and $f$, with $d>0$, then the corresponding database entries are numbered $f, f+1, \dots, f+d-1$.

### `IdentifyAlmostSimpleGroup(G): GrpPerm -> Map, GrpPerm`

### `IdentifyAlmostSimpleGroup(G): GrpMat -> Map, GrpPerm`

Use the information in the database to construct a monomorphism $f$ from the almost simple group $G$ into $A$, the permutation representation of the full automorphism group of its socle stored in the database. This function will also cope with groups isomorphic to the alternating and symmetric groups of degree up to 50, which are not actually in the database. Note that the conjugacy class of the image of $f$ in $A$ determines $G$ up to isomorphism. The algorithms used to deal with the alternating and symmetric groups not in the database are by Derek Holt, starting from the paper of Bratus & Pak [[Bratus and Pak, 2000](../../references.md#cite-bratus-pak)].

### `Example: sgdb (ex-6b4019)`

We query the database on about an almost simple group of order 720.

```magma
> G := PermutationGroup<10 |
>  [ 7, 9, 5, 2, 1, 8, 10, 4, 6, 3 ],
>  [ 6, 3, 10, 7, 2, 4, 1, 8, 9, 5 ]>;
> #G;
720
> CompositionFactors(G);
    G
    |  Cyclic(2)
    *
    |  Alternating(6)
    1
> #Radical(G);
1

```

There are 3 such groups, so we really do need $k$ to tell them apart.

```magma
> S := SolubleResidual(G);
> k := &+[c[1]: c in Classes(G)];
> D := AlmostSimpleGroupDatabase();
> R := GroupData(D, #S, #G, k);
> R`name;
M_10

```

The group is identified. Let’s see some of the other information in $R$.

```magma
> P := R`permrep;
> P;
Permutation group P acting on a set of cardinality 10
  (1, 6)(2, 9)(3, 10)(4, 8)
  (1, 7, 9, 4)(2, 8, 5, 10)
  (3, 5, 9, 6, 7, 4, 8, 10)
  (3, 7)(4, 6)(5, 10)
> #P;
1440
> R`subgens;
[ t * u ]
> SS := sub<P|P.1, P.2>;
> #SS;
360
> GG := sub<P|SS, P.3*P.4>;
> #GG;
720
> R`normgens;
[ t ]

```

The full automorphism group of $S$ has order 1440. The group $P$ is a representation of this automorphism group with first two generators generating a faithful image of $S$. The image of $S$, together with the product of `P.3` and `P.4`, generate a faithful image of $G$. The outer automorphism group of $G$ is generated by `P.3` modulo `GG`. We can also get a constructive identification as follows.

```magma
> f, A := IdentifyAlmostSimpleGroup(G);
> f;
Homomorphism of GrpPerm: $, Degree 10, Order 2^4 * 3^2 * 5
into GrpPerm: A, Degree 10 induced by
  (1, 10)(3, 8)(5, 9)(6, 7) |--> (1, 6)(2, 9)(3, 10)(4, 8)
  (1, 7, 2, 8)(3, 10, 4, 5) |--> (1, 7, 9, 4)(2, 8, 5, 10)
  (1, 10, 4, 8)(2, 6, 9, 5) |--> (3, 10, 7, 6)(4, 8, 5, 9)
> A;
Permutation group A acting on a set of cardinality 10
  (1, 6)(2, 9)(3, 10)(4, 8)
  (1, 7, 9, 4)(2, 8, 5, 10)
  (3, 5, 9, 6, 7, 4, 8, 10)
  (3, 7)(4, 6)(5, 10)

```