;
```
The generators of $N$ have been chosen to be a normal generating set for the derived group of $G$.
```magma
> IsProbablyPerfect(N);
false
> x := NormalSubgroupRandomElement(G, N);
> x;
[$.1^68 $.1^34 $.1^26 $.1^55]
[$.1^23 $.1^78 $.1^16 $.1^72]
[$.1^42 $.1^2 $.1^24 2]
[$.1^11 $.1^66 $.1^13 $.1^29]
> L := sub< G | N, x>;
> IsProbablyPerfect(L);
true
```
We now consider $SO(7, 5)$ and $\Omega(7, 5)$.
```magma
> G := SO(7, 5);
> IsProbablyPerfect(G);
false
> G := Omega(7, 5);
> IsProbablyPerfect(G);
true
```
### Aschbacher Reduction
#### Introduction
An on-going international research project seeks to develop algorithms to explore the structure of groups having either large order or large degree. The approach relies on the following theorem of Aschbacher [[Asc84](https://docs.magma-maths.org/references.md#cite-asch-maximal-subgps)]:
A matrix group $G$ acting on the finite dimensional $K[G]$-module $V$ over a finite field $K$ satisfies at least one of the following conditions (which we have simplified slightly for brevity):
**(i)**
$G$ acts reducibly on $V$;
**(ii)**
$G$ acts semilinearly over an extension field of $K$;
**(iii)**
$G$ acts imprimitively on $V$;
**(iv)**
$G$ preserves a nontrivial tensor-product decomposition of $V$;
**(v)**
$G$ has a normal subgroup $N$, acting absolutely irreducibly on $V$, which is an extraspecial $p$-group or 2-group of symplectic type;
**(vi)**
$G$ preserves a tensor-induced decomposition of $V$;
**(vii)**
$G$ acts (modulo scalars) linearly over a proper subfield of $K$;
**(viii)**
$G$ contains a classical group in its natural action over $K$;
**(ix)**
$G$ is almost simple modulo scalars.
The philosophy underpinning the research program is to attempt to decide that $G$ lies in at least one of the above categories, and to calculate the associated isomorphism or decomposition explicitly. Groups in Category (i) can be recognised easily by means of the Meataxe functions described in the chapter on $R$-modules. Groups which act irreducibly but not absolutely irreducibly on $V$ fall theoretically into Category (ii), and furthermore act linearly over an extension field of $K$. In fact, absolute irreducibility can be tested using the built-in Magma functions and, by redefining their field to be an extension field $L$ of $K$ and reducing, they can be rewritten as absolutely irreducible groups of smaller dimension, but over $L$ instead of $K$. We can therefore concentrate on absolutely irreducible matrix groups. The `CompositionTree` package currently includes functions which seek to decide membership in all categories.
#### Primitivity
Let $G$ be a subgroup of ${\operatorname{GL}}(d, q)$ and assume that $G$ acts irreducibly on the underlying vector space $V$. Then $G$ acts *imprimitively* on $V$ if there is a non-trivial direct sum decomposition
$$
V = V_1 \oplus V_2 \oplus \ldots \oplus V_r
$$
where $V_1,\ldots, V_r$ are permuted by $G$. In such a case, each block $V_i$ has the same dimension or size, and we have the *block system* $\{V_1, \ldots, V_r\}$. If no such system exists, then $G$ is *primitive*.
Theoretical details of the algorithm used may be found in Holt, Leedham-Green, O’Brien, and Rees [[HLGOR96b](https://docs.magma-maths.org/references.md#cite-matg-primitivity)].
`SetVerbose ("Smash", 1)` will provide information on the progress of the algorithm.
##### `IsPrimitive(G: parameters): GrpMat -> BoolElt`
```magma
BlockSizes: [RngIntElt] Default: []
```
Given a matrix group $G$ defined over a finite field, this intrinsic returns `true` if $G$ is primitive, `false` if $G$ is not primitive, or `"unknown"` if no decision can be reached.
If `BlockSizes` is supplied, then the search is restricted to systems of imprimitivity whose block sizes are given in the sequence `BlockSizes` only. Otherwise all valid sizes will be considered.
##### `ImprimitiveBasis(G): GrpMat -> SeqEnum`
Given a matrix group $G$ defined over a finite field which is imprimitive, this intrinsic returns the change-of-basis matrix which exhibits the block structure for $G$.
##### `Blocks(G): GrpMat -> SeqEnum`
Given a matrix group $G$ defined over a finite field which is imprimitive, this intrinsic returns the blocks of imprimitivity of $G$.
##### `BlocksImage(G): GrpMat -> GrpPerm`
Given a matrix group $G$ defined over a finite field which is imprimitive, this intrinsic returns the group induced by the action of $G$ on the system of imprimitivity.
##### `ImprimitiveAction(G, g): GrpMat, GrpMatElt -> GrpPermElt`
Given a matrix group $G$ defined over a finite field which is imprimitive and an element $g$ of $G$, this intrinsic returns action of $g$ on blocks of imprimitivity as a permutation.
##### `Example: Testing for Primitivity (ex-cc4edb)`
We construct an imprimitive group by taking the wreath product of $GL(4, 7)$ with $S_3$.
```magma
> MG := GL (4, 7);
> PG := Sym (3);
> G := WreathProduct (MG, PG);
>
> IsPrimitive (G);
false
```
We investigate the block system for $G$.
```magma
> B := Blocks (G);
> B;
> #B;
3
> B[1];
Vector space of degree 12, dimension 4 over GF(7)
Generators:
(0 0 0 0 1 0 0 0 0 0 0 0)
(0 0 0 0 0 1 0 0 0 0 0 0)
(0 0 0 0 0 0 1 0 0 0 0 0)
(0 0 0 0 0 0 0 1 0 0 0 0)
Echelonized basis:
(0 0 0 0 1 0 0 0 0 0 0 0)
(0 0 0 0 0 1 0 0 0 0 0 0)
(0 0 0 0 0 0 1 0 0 0 0 0)
(0 0 0 0 0 0 0 1 0 0 0 0)
```
Now we obtain a permutation representation of $G$ in its action on the blocks.
```magma
> P := BlocksImage (G);
> P;
Permutation group P acting on a set of cardinality 3
(1, 2, 3)
(2, 3)
> g := G.4 * G.3;
> ImprimitiveAction (G, g);
(1, 2)
```
#### Semilinearity
Let $G$ be a subgroup of ${\operatorname{GL}}(d, q)$ and assume that $G$ acts absolutely irreducibly on the underlying vector space $V$. Assume that a normal subgroup $N$ of $G$ embeds in ${\operatorname{GL}}(d/e,q^e)$, for $e>1$, and a $d \times d$ matrix $C$ acts as multiplication by a scalar $\lambda$ (a field generator of ${\bf F}_{q^e}$) for that embedding. We say that $G$ acts as a *semilinear* group of automorphisms on the $d/e$-dimensional space if and only if, for each generator $g$ of $G$, there is an integer $i = i(g)$ such that $Cg = gC^{i}$, that is, $g$ corresponds to the field automorphism $\lambda \rightarrow \lambda^{i}$. If so, we have a map from $G$ to the (cyclic) group ${\rm Aut}(GF(q^e))$, and $C$ centralises the kernel of this map, which thus lies in ${\operatorname{GL}}(d,q^e)$.
Theoretical details of the algorithm used may be found in Holt, Leedham-Green, O’Brien, and Rees [[HLGOR96a](https://docs.magma-maths.org/references.md#cite-decomps-modules)].
`SetVerbose ("SemiLinear", 1)` will provide information on the progress of the algorithm.
##### `IsSemiLinear(G): GrpMat -> BoolElt`
Given a matrix group $G$ defined over a finite field, this intrinsic returns `true` if $G$ is semilinear, `false` if $G$ is not semilinear, or `"unknown"` if no decision can be reached.
##### `DegreeOfFieldExtension(G): GrpMat -> RngIntElt`
Let $G$ be a subgroup of $K = {\operatorname{GL}}(d, q)$. The intrinsic returns the degree $e$ of the extension field of $F_q$ over which $G$ is semilinear.
##### `CentralisingMatrix(G): GrpMat -> AlgMatElt`
Let $G$ be a semilinear subgroup of $K = {\operatorname{GL}}(d, q)$. The intrinsic returns the matrix $C$ which centralises the normal subgroup of $G$ which acts linearly over the extension field of $F_q$.
##### `FrobeniusAutomorphisms(G): GrpMat -> SeqEnum`
Let $G$ be a semilinear subgroup of $K = {\operatorname{GL}}(d, q)$ and let $C$ be the corresponding centralising matrix. The intrinsic returns a sequence $S$ of positive integers, one for each generator $g_i$ of $G$. The element $S[i]$ is the least positive integer such that $g_i^{-1} C g_i = C^{S[i]}$.
##### `WriteOverLargerField(G): GrpMat -> GrpMat, GrpAb, SeqEnum`
Let $G$ be a semilinear subgroup of ${\operatorname{GL}}(d, q)$ with extension degree $e$. This intrinsic returns:
**(i)**
The normal subgroup $N$ of the matrix group $G$ which is the kernel of the map from $G$ to $C_e$; this subgroup acts linearly over the extension field of $K$ and is precisely the centraliser of $C$ in $G$.
**(ii)**
A cyclic group $E$ of order $e$ which is isomorphic to $G/N$.
**(iii)**
A sequence of images of the generators of $G$ in $E$.
##### `Example: Analysing a Semilinear Group (ex-0459a8)`
We analyse a semilinear group.
```magma
> P := GL(6,3);
> g1 := P![0,1,0,0,0,0,-1,0,0,0,0,0,
> 0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1];
> g2 := P![-1,0,0,0,1,0,0,-1,0,0,0,1,
> -1,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0];
> g3 := P![1,0,0,0,0,0,0,-1,0,0,0,0,
> 0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,-1];
> G := sub ;
>
> IsSemiLinear (G);
true
> DegreeOfFieldExtension (G);
2
> CentralisingMatrix (G);
[2 2 0 0 0 0]
[1 2 0 0 0 0]
[0 0 2 2 0 0]
[0 0 1 2 0 0]
[0 0 0 0 2 2]
[0 0 0 0 1 2]
> FrobeniusAutomorphisms (G);
[ 1, 1, 3 ]
> K, E, phi := WriteOverLargerField (G);
```
The group $K$ is the kernel of the homomorphism from $G$ into $E$.
```magma
> K.1;
[0 1 0 0 0 0]
[2 0 0 0 0 0]
[0 0 1 0 0 0]
[0 0 0 1 0 0]
[0 0 0 0 1 0]
[0 0 0 0 0 1]
```
The return value $E$ is the cyclic group of order $e$ while `phi` gives the sequence of images of $G.i$ in $E$.
```magma
> E;
Abelian Group isomorphic to Z/2
Defined on 1 generator
Relations:
2*E.1 = 0
>
> phi;
[ 0, 0, E.1 ]
```
#### Tensor Products
Let $G$ be a subgroup of ${\operatorname{GL}}(d, K)$, where $K = GF(q)$, and let $V$ be the natural $K[G]$-module. We say that $G$ preserves a tensor decomposition of $V$ as $U\otimes W$ if there is an isomorphism of $V$ onto $U\otimes W$ such that the induced image of $G$ in ${\operatorname{GL}}(U\otimes W)$ lies in ${\operatorname{GL}}(U) \circ {\operatorname{GL}}(W)$.
Theoretical details of the algorithm used may be found in Leedham-Green and O’Brien [[LGO97a](https://docs.magma-maths.org/references.md#cite-recog-tensor), [LGO97b](https://docs.magma-maths.org/references.md#cite-tp-pg)].
The verbose flag `SetVerbose ("Tensor", 1)` will provide information on the progress of the algorithm.
##### `IsTensor(G: parameters): GrpMat -> BoolElt`
```magma
Factors: [SeqEnum] Default: []
```
Given a matrix group $G$ defined over a finite field, this intrinsic returns `true` if $G$ preserves a non-trivial tensor decomposition, `false` if $G$ is does not preserve a tensor decomposition, or `"unknown"` if no decision can be reached.
A sequence of valid dimensions for potential factors may be supplied using the parameter `Factors`. Then for each element $[u, w]$ of the sequence `Factors`, the algorithm will search for decompositions of $V$ as $U \otimes W$, where $U$ must have dimension $u$ and $W$ must have dimension $w$ only. If this parameter is not set, then all valid factorisations will be considered.
##### `TensorBasis(G): GrpMat -> GrpMatElt`
Given a matrix group $G$ defined over a finite field that admits a tensor decomposition, this intrinsic returns the change-of-basis matrix which exhibits the tensor decomposition of $G$.
##### `TensorFactors(G): GrpMat -> GrpMat, GrpMat`
Given a matrix group $G$ defined over a finite field that admits a tensor decomposition, this intrinsic returns two groups which are the tensor factors of $G$.
##### `IsProportional(X, k): Mtrx, RngIntElt -> BoolElt, Tup`
Given a matrix group $G$ defined over a finite field that admits a tensor decomposition, this intrinsic returns `true` if and only if the matrix $X$ is composed of $k \times k$ blocks which differ only by scalars. If this is indeed the case, the tensor decomposition of $X$ is also returned.
##### `Example: Tensor Decomposition of a Matrix Group (ex-8c10fc)`
We define a subgroup of $GL(6, 3)$ which admits a non-trivial tensor decomposition.
```magma
> P := GL(6, 3);
>
> g := P![ 0, 1, 1, 2, 1, 0, 2, 2, 1, 2, 1, 1, 1, 0, 2, 1, 2, 2, 1, 2, 2,
> 2, 2, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 2, 2 ];
>
> h := P![ 1, 0, 2, 1, 1, 2, 0, 0, 2, 0, 0, 2, 2, 0, 1, 0, 2, 1, 2, 1, 2,
> 2, 1, 1, 0, 2, 0, 1, 0, 0, 0, 0, 0, 2, 1, 2 ];
>
> G := sub< P | g, h >;
> IsTensor(G);
true
> C := TensorBasis(G);
```
So $C$ is the change-of-basis matrix. If we conjugate $G.1$ by $C$, we obtain a visible Kronecker product.
```magma
> G.1^C;
[0 0 2 0 2 0]
[0 0 2 2 2 2]
[2 0 0 0 2 0]
[2 2 0 0 2 2]
[0 0 0 0 1 0]
[0 0 0 0 1 1]
>
```
We use the function `IsProportional` to verify that $G.1^C$ is a Kronecker product.
```magma
> IsProportional(G.1^C, 2);
true
<
[2 0]
[2 2],
[0 1 1]
[1 0 1]
[0 0 2]
>
```
Finally, we display the tensor factors.
```magma
> A := TensorFactors(G);
> A[1];
MatrixGroup(2, GF(3))
Generators:
[1 2]
[2 2]
[2 0]
[2 2]
> A[2];
MatrixGroup(3, GF(3))
Generators:
[0 1 0]
[1 2 1]
[1 2 0]
[0 1 1]
[1 0 1]
[0 0 2]
```
#### Tensor-induced Groups
Let $G$ be a subgroup of ${\operatorname{GL}}(d, K)$, where $K = {\bf F}_{q}$ and $q = p^e$ for some prime $p$, and let $V$ be the natural $K[G]$-module. Assume that $d$ has a proper factorisation as $u^r$. We say that $G$ is tensor-induced if $G$ preserves a decomposition of $V$ as
$$
U_1 \otimes U_2 \otimes \cdots \otimes U_r
$$
where each $U_i$ has dimension $u > 1$, $r > 1$, and the set of $U_i$ is permuted by $G$. If $G$ is tensor-induced, then there is a homomorphism of $G$ into the symmetric group $S_r$.
Theoretical details of the algorithm used may be found in Leedham-Green and O’Brien [[LGO02](https://docs.magma-maths.org/references.md#cite-crlg-eaob)].
`SetVerbose ("TensorInduced", 1)` will provide information on the progress of the algorithm.
##### `IsTensorInduced(G : parameters): GrpMat -> BoolElt`
```magma
InducedDegree: RngIntElt Default: "All"
```
Given a matrix group $G$ defined over a finite field, return `true` if $G$ is tensor-induced, `false` if $G$ is not tensor-induced, and `"unknown"` if no decision can be reached.
If the value of the parameter `InducedDegree` is set to $r$, then the algorithm will search for homomorphisms into the symmetric group of degree $r$ only. Otherwise is will consider all valid degrees.
##### `TensorInducedBasis(G): GrpMat -> GrpMatElt`
Given a matrix group $G$ defined over a finite field that is tensor-induced, this intrinsic returns the change-of-basis matrix which exhibits that $G$ is tensor-induced.
##### `TensorInducedPermutations(G): GrpMat -> SeqEnum`
Given a matrix group $G$ defined over a finite field that is tensor-induced, this intrinsic returns a sequence whose $i$-th entry is the homomorphic image of $G.i$ in $S_r$.
##### `TensorInducedAction(G, g): GrpMat, GrpMatElt -> GrpPermElt`
Given a matrix group $G$ defined over a finite field that is tensor-induced, this intrinsic returns the tensor-induced action of the element $g \in G$.
##### `Example: Tensor-Induced Groups (ex-1ef8b8)`
We illustrate the use of the functions for determining if a matrix group is tensor-induced.
```magma
> G := GL(2, 3);
> S := Sym(3);
> G := TensorWreathProduct(G, S);
> IsTensorInduced(G);
true
```
We next recover the permutations.
```magma
> TensorInducedPermutations(G);
[
Id(S),
Id(S),
(1, 2, 3),
(1, 2)
]
```
Hence $G.1$ and $G.2$ are in the kernel of the homomorphism from $G$ to $S$. We extract the change-of-basis matrix $C$ and then conjugate $G.1$ by $C$, thereby obtaining a visible Kronecker product.
```magma
> C := TensorInducedBasis(G);
> x := G.1^C;
> x;
[2 0 0 0 0 0 0 0]
[0 2 0 0 0 0 0 0]
[0 0 2 0 0 0 0 0]
[0 0 0 2 0 0 0 0]
[1 0 0 0 1 0 0 0]
[0 1 0 0 0 1 0 0]
[0 0 1 0 0 0 1 0]
[0 0 0 1 0 0 0 1]
```
Finally, we verify that $x = G.1^C$ is a Kronecker product for each of $2$ and $4$.
```magma
> IsProportional(x, 2);
true
<[2 0]
[0 2], [1 0 0 0]
[0 1 0 0]
[2 0 2 0]
[0 2 0 2]>
> IsProportional(x, 4);
true
<[2 0 0 0]
[0 2 0 0]
[0 0 2 0]
[0 0 0 2], [1 0]
[2 2]>
```
#### Normalisers of Extraspecial $r$-groups and Symplectic 2-groups
Let $G \leq GL(d, q)$, where $d=r^m$ for some prime $r$. If $G$ is contained in the normaliser of an $r$-group $R$, of order either $r^{2m+1}$ or $2^{2m+2}$, then either $R$ is extraspecial (in the first case), or $R$ is a $2$-group of symplectic type (that is, a central product of an extraspecial $2$-group with the cyclic group of order $4$).
If $d = r$ is an odd prime, we use the Monte Carlo algorithm of Niemeyer [[Nie05](https://docs.magma-maths.org/references.md#cite-niemeyer-normalisers)] to decide whether or not $G$ normalises such a subgroup. Otherwise, the corresponding intrinsic `IsExtraSpecialNormaliser` searches for elements of the normal subgroup, and can only reach a negative conclusion in certain limited cases. If it cannot reach a conclusion it returns `"unknown"`.
##### `IsExtraSpecialNormaliser(G): GrpMat -> BoolElt`
Given a matrix group $G$ defined over a finite field, the intrinsic returns `true` if $G$ normalises an extraspecial $r$-group or 2-group of symplectic type, `false` if $G$ is known not to normalise an extraspecial $r$-group or a 2-group of symplectic type, or `"unknown"` if it cannot reach a conclusion.
##### `ExtraSpecialParameters(G): GrpMat -> [RngIntElt, RngIntElt]`
Given a matrix group $G$ defined over a finite field that is known to normalise an extraspecial $r$-group or 2-group of symplectic type, this intrinsic returns a sequence of two integers, $r$ and $n$, where the extraspecial or symplectic subgroup $R$ normalised by $G$ has order $r^{n}$.
##### `ExtraSpecialGroup(G): GrpMat -> GrpMat`
Given a matrix group $G$ defined over a finite field that is known to normalise an extraspecial $r$-group or 2-group of symplectic type, this intrinsic returns the extraspecial or symplectic subgroup normalised by $G$.
##### `ExtraSpecialNormaliser(G): GrpMat -> SeqEnum`
Given a matrix group $G$ defined over a finite field that is known to normalise an extraspecial $r$-group or 2-group of symplectic type, this intrinsic returns the action of the generators of $G$ on its normal extraspecial or symplectic subgroup as a sequence of matrices, each of degree $2r$, one for each generator of $G$.
##### `ExtraSpecialAction(G, g): GrpMat, GrpMatElt -> GrpMatElt`
Given a matrix group $G$ defined over a finite field that is known to normalise an extraspecial $r$-group or 2-group of symplectic type, this intrinsic returns a matrix of degree $2r$ describing the action of element $g$ on the extraspecial or symplectic group normalised by $G$.
##### `ExtraSpecialBasis(G): GrpMat -> GrpMatElt`
Given a matrix group $G$ defined over a finite field, which is the odd prime degree case of $G$ normalising an extraspecial $r$-group or 2-group of symplectic type, this intrinsic returns the change-of-basis matrix which conjugates the normal extraspecial subgroup into a “nice” representation, generated by a diagonal and a permutation matrix.
##### `Example: Normaliser of an Extraspecial Group (ex-2adbb0)`
For this example we construct a subgroup $G$ of ${\operatorname{GL}}(7, 8)$ that normalises an extraspecial $r$-group or $2$-group of symplectic type.
```magma
> F:=GF(8);
> P:=GL(7,F);
> w := PrimitiveElement(F);
> g1:=P![
> w,0,w^2,w^5,0,w^3,w,w,1,w^6,w^3,0,w^4,w,w^2,w^6,w^4,1,w^3,w^3,w^5,
> w^6,w,w^3,1,w^5,0,w^4,1,w^6,w^3,w^6,w^3,w^2,w^2,w^3,w^6,w^6,w^4,1,w^2,w^4,
> w^5,w^4,w^2,w^6,1,w^5,w ];
> g2:=P![w^3,w^4,w^2,w^6,w,w,w^3,w^3,w^4,w,w,w^2,w^3,w^3,w,w^3,w^5,w,1,w^3,w,
> 0,w^2,w^6,w,w^5,1,w,w^6,0,w^3,0,w^4,w,w^5,w^3,w^3,1,w^3,w^5,w^5,w^3,
> w^4,w^6,w,w^6,w^4,w^4,0 ];
> g3:=P![w^5,w^6,w^2,w,w,w^4,w^6,w^6,w^6,w,w^6,w,1,w^3,w,w^6,w^2,w,w^6,w^3,w^6,
> w^2,w^6,w^6,w^3,w,w^6,w^5,0,w^4,w^6,w^6,w,w^2,0,w,w^3,w^5,w^2,w^3,w^4,w^6,
> 0,w^3,w,w^3,w^4,w^3,1];
> gens := [g1,g2,g3];
> G := sub< P | gens >;
> IsExtraSpecialNormaliser(G);
true
```
So $G$ has the desired normaliser property.
```magma
> ExtraSpecialParameters (G);
[ 7, 3 ]
> N:=ExtraSpecialNormaliser(G);
> N;
[
[3 4]
[1 4],
[4 3]
[0 2],
[1 0]
[0 1]
]
```
#### Writing Representations over Subfields
The algorithm implemented by these functions is due to Glasby, Leedham-Green, and O’Brien [[GLGO05](https://docs.magma-maths.org/references.md#cite-glasby-lg-obrien)]. We also provide access to an earlier algorithm for the non-scalar case developed by Glasby and Howlett [[GH97](https://docs.magma-maths.org/references.md#cite-minimal-fields)].
##### `IsOverSmallerField(G : parameters): GrpMat -> BoolElt, GrpMat`
```magma
Scalars : BoolElt Default: false
Algorithm: MonStgElt Default: "GLO"
```
Given an absolutely irreducible matrix group $G$ defined over a finite field $K$, this intrinsic decides whether or not $G$ has an equivalent representation over a subfield of $K$. If so, it returns `true` and the representation over the smallest possible subfield, otherwise it returns `false`. If the optional argument `Scalars` is `true` then decide whether or $G$ modulo scalars has an equivalent representation over a subfield of $K$. If the optional argument `Algorithm` is set to `"GH"`, then the non-scalar case uses the original Glasby and Howlett algorithm. The default is the Glasby, Leedham-Green, and O’Brien algorithm, specified by `"GLO"`.
##### `IsOverSmallerField(G, k : parameters): GrpMat -> BoolElt, GrpMat`
```magma
Scalars : BoolElt Default: false
Algorithm: MonStgElt Default: "GLO"
```
Given an absolutely irreducible matrix group $G$ defined over a finite field $K$, and a positive integer $k$ which is a proper divisor of the degree of $K$, this intrinsic decides whether or not $G$ has an equivalent representation over a proper subfield of $K$ having degree $k$ over the prime field. If so, it returns `true` and the representation over this subfield, else it returns `false`. If the optional argument `Scalars` is `true` then it decides whether or not $G$ modulo scalars has an equivalent representation over a degree $k$ subfield of $K$. If the optional argument `Algorithm` is set to `"GH"`, then the non-scalar case uses the original Glasby and Howlett algorithm. The default is the Glasby, Leedham-Green, and O’Brien algorithm, specified by `"GLO"`.
##### `SmallerField(G): GrpMat -> FLdFin`
Given an absolutely irreducible matrix group $G$ defined over a finite field $K$, which can be written over a proper subfield of $K$ (possibly modulo scalars), return the subfield.
##### `SmallerFieldBasis(G): GrpMat -> GrpMatElt`
Given an absolutely irreducible matrix group $G$ defined over a finite field $K$, which can be written over a proper subfield of $K$ (possibly modulo scalars), return the change of basis matrix for $G$ which rewrites $G$ over the smaller field.
##### `SmallerFieldImage(G, g): GrpMat, GrpMatElt -> GrpMatElt`
Given an absolutely irreducible matrix group $G$ defined over a finite field $K$, which can be written over a proper subfield of $K$ (possibly modulo scalars), return the image of $g \in G$ in the group defined over the subfield.
##### `Example: Detecting a Smaller Field of Definition (ex-3b0781)`
We define a subgroup of ${\operatorname{GL}}(3, 8)$ which can be written over ${\bf F}_{2}$.
```magma
> G := GL (2, GF (3, 2));
> H := GL (2, GF (3, 8));
> K := sub < H | G.1, G.2 >;
> K;
MatrixGroup(2, GF(3^8))
Generators:
[ $.1^820 0]
[ 0 1]
[ 2 1]
[ 2 0]
> flag, M := IsOverSmallerField (K);
> flag;
true
> M;
MatrixGroup(2, GF(3^2))
Generators:
[$.1^7 $.1^2]
[ 1 2]
[$.1^7 $.1^6]
[$.1^2 $.1^5]
> F := GF(3, 4);
> G := MatrixGroup<2, F | [ F.1^52, F.1^72, F.1^32, 0 ],
> [ 1, 0, F.1^20, 2 ] >;
> flag, X := IsOverSmallerField (G);
> flag;
false
```
We now see if $G$ has an equivalent representation modulo scalars.
```magma
> flag, X := IsOverSmallerField (G: Scalars := true);
> flag;
true
> X;
MatrixGroup(2, GF(3))
Generators:
[2 1]
[1 0]
[2 1]
[1 1]
> SmallerField (G);
Finite field of size 3
> SmallerFieldBasis (G);
[F.1^33 F.1^23]
[F.1^43 F.1^63]
> g := G.1 * G.2^2; g;
[F.1^52 F.1^72]
[F.1^32 0]
> SmallerFieldImage (G, g);
[1 2]
[2 0]
```
##### `WriteOverSmallerField(G, F): GrpMat, FldFin -> GrpMat, Map`
Given a group $G$ of $d \times d$ matrices over a finite field $E$ having degree $e$ and a subfield $F$ of $E$ having degree $f$, write the matrices of $G$ as $de/f$ by $de/f$ matrices over $F$ and return the group and the isomorphism.
##### `Example: Rewriting over a Smaller Field (ex-c2e1e0)`
We define the group ${\operatorname{GL}}(2, 4)$ and then rewrite in over ${\bf F}_{2}$ as a degree 4 matrix group.
```magma
> G := GL(2, 4);
> H := WriteOverSmallerField(G, GF(2));
> H;
MatrixGroup(4, GF(2))
Generators:
[0 1 0 0]
[1 1 0 0]
[0 0 1 0]
[0 0 0 1]
[1 0 1 0]
[0 1 0 1]
[1 0 0 0]
[0 1 0 0]
```
#### Decompositions with Respect to a Normal Subgroup
##### `SearchForDecomposition(G, S): GrpMat, [GrpMatElt] -> BoolElt`
Given a matrix group $G$ defined over a finite field and a sequence $S$ of elements of $G$, this intrinsic first constructs the normal closure $N$ of $S$ in $G$. It then seeks to decide whether or not $G$, with respect to $N$, has a decomposition corresponding to one of the categories (ii)–(vi) in the theorem of Aschbacher stated at the beginning of this section. Theoretical details of the algorithms used may be found in Holt, Leedham-Green, O’Brien, and Rees [[HLGOR96a](https://docs.magma-maths.org/references.md#cite-decomps-modules)]. In summary, it tests for one of the following possibilities:
**(ii)**
$G$ acts semilinearly over an extension field $L$ of $K$, and $N$ acts linearly over $L$;
**(iii)**
$G$ acts imprimitively on $V$ and $N$ fixes each block of imprimitivity;
**(iv)**
$G$ preserves a tensor product decomposition $U \otimes W$ of $V$, where $N$ acts as scalar matrices on $U$;
**(v)**
$N$ acts absolutely irreducibly on $V$ and is an extraspecial $p$-group for some prime $p$, or a 2-group of symplectic type;
**(vi)**
$G$ preserves a tensor-induced decomposition $V = \otimes ^mU$ of $V$ for some $m>1$, where $N$ acts absolutely irreducibly on $V$ and fixes each of the $m$ factors. If one of the listed decompositions is found, then the function *reports* the type found and returns `true`; if no decomposition is found with respect to $N$, then the function returns `false`. The answer provided by the function is conclusive for decompositions of types (ii)–(v), but a negative answer for (vi) is not necessarily conclusive. Each test involves a decomposition of $G$ with respect to the normal subgroup $N$ (which may sometimes be trivial or scalar). In (ii), $N$ is the subgroup of $G$ acting linearly over the extension field irreducibly on $V$. In (iii), $N$ is the subgroup which fixes each of the subspaces in the imprimitive decomposition of $V$. In (iv), it is the subgroup acting as scalar matrices on one of the factors in the tensor-product decomposition. In (v), $N$ is already described, and in (vi), it is the subgroup fixing each of the factors in the tensor-induced decomposition (so $N$ itself falls in Category (iv)). If any one of these decompositions can be found, then it may be possible to obtain an explicit representation of $G/N$ and hence reduce the study of $G$ to a smaller problem. For example, in Category (iii), $G/N$ acts as a permutation group on the subspaces in the imprimitive decomposition of $V$. Currently only limited facilities are provided to construct $G/N$.
Information about the progress of the algorithm can be output by setting the verbose flag `SetVerbose ("Smash", 1)`.
##### Accessing the Decomposition Information
The access functions described in the sections on Primitivity Testing, Semilinearity, Tensor Products, Tensor Induction, and Normalisers of extraspecial groups may be used to extract information about decompositions of type (ii), (iii), (iv), (v) and (vi). We illustrate such decompositions below.
###### `Example: Searching for a Decomposition (ex-14d37b)`
We begin with an example where no decomposition exists.
```magma
> G := GL(4, 5);
> SearchForDecomposition (G, [G.1]);
Smash: No decomposition found
false
```
The second example is of an imprimitive decomposition.
```magma
> M := GL (4, 7);
> P := Sym (3);
> G := WreathProduct (M, P);
> SearchForDecomposition (G, [G.1, G.2]);
Smash: G is imprimitive
true
> IsPrimitive (G);
false
> BlocksImage (G);
Permutation group acting on a set of cardinality 3
Id($)
Id($)
(1, 2, 3)
(1, 2)
```
The third example admits a semilinear decomposition.
```magma
> P := GL(6,3);
> g1 := P![0,1,0,0,0,0,-1,0,0,0,0,0,
> 0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1];
> g2 := P![-1,0,0,0,1,0,0,-1,0,0,0,1,
> -1,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0];
> g3 := P![1,0,0,0,0,0,0,-1,0,0,0,0,
> 0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,-1];
> G := sub
;
>
> SearchForDecomposition (G, [g1]);
Smash: G is semilinear
true
> IsSemiLinear (G);
true
> DegreeOfFieldExtension (G);
2
> CentralisingMatrix (G);
[2 2 0 0 0 0]
[1 2 0 0 0 0]
[0 0 2 2 0 0]
[0 0 1 2 0 0]
[0 0 0 0 2 2]
[0 0 0 0 1 2]
> FrobeniusAutomorphisms (G);
[ 1, 1, 3 ]
```
The fourth example admits a tensor product decomposition.
```magma
> F := GF(5);
> G := GL(5, F);
> H := GL(3, F);
> P := GL(15, F);
> A := MatrixAlgebra (F, 5);
> B := MatrixAlgebra (F, 3);
> g1 := A!G.1; g2 := A!G.2; g3 := A!Identity(G);
> h1 := B!H.1; h2 := B!H.2; h3 := B!Identity(H);
> w := TensorProduct (g1, h3);
> x := TensorProduct (g2, h3);
> y := TensorProduct (g3, h1);
> z := TensorProduct (g3, h2);
> G := sub < P | w, x, y, z>;
> SearchForDecomposition (G, [G.1, G.2]);
Smash: G is a tensor product
true
> IsTensor (G);
true
> TensorBasis (G);
[1 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 1 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 1 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 0 0 0 1 0 0 0 0 0]
[4 0 1 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 4 0 1 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 4 0 1 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 4 0 1]
[0 0 0 0 0 0 0 0 0 4 0 1 0 0 0]
[1 4 4 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 1 4 4 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 1 4 4 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 1 4 4]
[0 0 0 0 0 0 0 0 0 1 4 4 0 0 0]
```
Our fifth example is of a tensor-induced decomposition.
```magma
> M := GL (3, GF(2));
> P := Sym (3);
> G := TensorWreathProduct (M, P);
> SearchForDecomposition (G, [G.1]);
Smash: G is tensor induced
true
>
> IsTensorInduced (G);
true
> TensorInducedPermutations (G);
[ Id(P), Id(P), (1, 3, 2), (1, 3) ]
```
Our final example is of a normaliser of a symplectic group.
```magma
> F := GF(5);
> P := GL(4,F);
> g1 := P![ 1,0,0,0,0,4,0,0,2,0,2,3,3,0,4,3];
> g2 := P![ 4,0,0,1,2,4,4,0,1,0,1,2,0,0,0,1];
> g3 := P![ 4,0,1,1,0,1,0,0,0,1,3,4,0,4,3,2];
> g4 := P![ 2,0,4,3,4,4,2,4,0,1,3,4,4,2,0,1];
> g5 := P![ 1,1,3,4,0,0,3,4,2,0,0,4,3,1,3,4];
> g6 := P![ 2,0,0,0,0,2,0,0,0,0,2,0,0,0,0,2];
> G := sub < P | g1, g2, g3, g4, g5, g6 >;
> SearchForDecomposition (G, [G.4]);
Smash: G is normaliser of symplectic 2-group
true
> IsExtraSpecialNormaliser (G);
true
> ExtraSpecialParameters (G);
[2, 6]
> g := G.1 * G.2;
> ExtraSpecialAction(G, g);
[0 1 0 0]
[1 1 0 0]
[0 1 1 1]
[1 1 1 0]
```
### Constructive Recognition for Simple Groups
For each finite non-abelian simple group $S$, we designate a specific *standard copy* of $S$. The standard copy has a designated set of *standard generators*. For example, the standard copy of ${\operatorname{Alt}}(n)$ is on $n$ points; its standard generators are $(1,2,3)$ and either of $(3,\ldots, n)$ or $(1, 2)(3,\ldots, n)$ according to the parity of $n$. For a projective representation, the standard copy is the quotient of a matrix group by its scalar subgroup. For example, the standard copy of ${\operatorname{PSL}}(n,q)$ is the quotient of ${\operatorname{SL}}(n,q)$ by its scalar subgroup.
To compute in a copy $G$ of $S$, we first construct effective isomorphisms between $G$ and its standard copy. We do this by finding generators in $G$ that correspond to the standard generators of $S$ under an isomorphism. More formally, a *constructive recognition algorithm* for a non-abelian simple group $G$ (possibly with decorations) solves the following problem: construct an isomorphism $\phi$ from $G$ to a standard copy $S$ of $G$, such that $\phi(g)$ can be computed efficiently for every $g \in G$. This is done by constructing standard generators in both $G$ and its standard copy $S$.
A *rewriting algorithm* for $G$ solves the *constructive membership problem*: given $g \in U \geq G = \langle X \rangle$, decide whether or not $g \in G$, and if so express $g$ as an SLP in $X$. (Here $U$ is the generic overgroup of $G$, such as ${\operatorname{GL}}(d,q)$ or ${\operatorname{Sym}}(n)$.) The rewriting algorithm is used to make the isomorphism between $S$ and $G$ effective. To compute the image of an arbitrary element $s$ of $S$ in $G$, we first write $s$ as an SLP in the standard generators of $S$ and then evaluate the SLP in the copy of the standard generators in $G$.
To verify that the homomorphism from $S$ to $G$ is an isomorphism, we can evaluate in $G$ a *standard presentation* for $S$ on its standard generators. If the copy of the standard generators in $G$ satisfy the presentation, then we have proved that we have an isomorphism.
For a detailed discussion of these topics, see [[LGO09](https://docs.magma-maths.org/references.md#cite-lgo-odd), [OBr11](https://docs.magma-maths.org/references.md#cite-obrien10)]. Here we discuss recognition of classical and exceptional groups. See `RecogniseAlternatingOrSymmetric` for alternating groups.
#### Constructive Recognition for Classical Groups
##### `ClassicalStandardGenerators(type, d, q): MonStgElt, RngIntElt, RngIntElt -> []`
This intrinsic produces the standard generators of Leedham-Green and O’Brien for the quasisimple classical group of specified type in dimension $d$ over a field of size $q$. The type is designated by the argument `type` which must be one of the strings “SL”, “Sp”, “SU”, “Omega”, “Omega-”, or “Omega+”. The standard generators generate a specific copy of a classical group and are defined in [[LGO09](https://docs.magma-maths.org/references.md#cite-lgo-odd)] and [[DLLGO13](https://docs.magma-maths.org/references.md#cite-dlgo-even)].
##### `ClassicalConstructiveRecognition(G, type, d, q): GrpMat[FldFin], MonStgElt, RngIntElt, RngIntElt -> BoolElt, Map, Map, Map, Map, SeqEnum, SeqEnum`
##### `ClassicalConstructiveRecognition(G): GrpMat[FldFin] -> BoolElt, SeqEnum, SeqEnum`
The input group $G = \langle X \rangle$ is a permutation group, or a matrix group defined over a finite field. It must be isomorphic to a central quotient of a classical group of specified type in dimension $d$ over a field of size $q$. The type is designated by one of the strings “SL”, “Sp”, “SU”, “Omega”, “Omega-”, or “Omega+”. The function constructs standard generators for $G$. If it is successful, then return `true`; four maps $m_1, m_2, m_3, m_4$; standard generators ${\cal S}$ for $G$; and their SLPs in $X$; otherwise return `false`. The map $m_1$ is from $G$ to the standard copy $S$ of $G$; the map $m_2$ is from $S$ to $G$; the map $m_3$ is from $G$ to `WordGroup(G)`; the map $m_4$ is from `WordGroup(G)` to $G$. Since, in general, $G$ is isomorphic to a central quotient of $S$, the maps $m_1$ and $m_2$ are homomorphisms modulo scalars.
In the second signature, $G$ must be a matrix group defined over a finite field such that $G = \langle X \rangle$ is conjugate to a quasisimple classical group in its natural representation in dimension at least 2. The intrinsic constructs a copy ${\cal S}$ in $G$ of the generators defined by `StandardGenerators`. If $G$ is quasisimple and classical, then the function returns `true`, the standard generators ${\cal S}$, and SLPs for these in $X$; otherwise it returns `false`.
The algorithms used are described in [[LGO09](https://docs.magma-maths.org/references.md#cite-lgo-odd)], [[DLLGO13](https://docs.magma-maths.org/references.md#cite-dlgo-even)], and [[DLGO15](https://docs.magma-maths.org/references.md#cite-dlgo-black)]. The implementations for even and odd characteristic were developed by Heiko Dietrich and Eamonn O’Brien respectively. Some base case functions were implemented by Kenneth Clarkson.
##### `Example: Constructive Recognition of Sp(6, 125) (ex-0be2ca)`
We illustrate these functions with two examples.
```magma
> G := Sp (6, 5^3);
> G := ExteriorSquare (G);
> f, m1, m2, m3, m4, E, W := ClassicalConstructiveRecognition( G, "Sp", 6, 5^3 );
> Q, R := ClassicalStandardPresentation ("Sp", 6, 5^3);
> #{Evaluate( r, E ) : r in R} eq 1;
true
> x := Random (G);
> y := m1 (x);
> y;
> w := m3 (x);
> "Length of SLP is ", #w;
> Evaluate (w, [G.i: i in [1..Ngens (G)]]) eq x;
true
> E eq Evaluate( W, [G.i : i in [ 1 .. Ngens( G )]]);
> G := PSL( 6, 4 );
> f, m1, m2, m3, m4, E, W := ClassicalConstructiveRecognition( G, "SL", 6, 4 );
> E eq Evaluate( W, [G.i : i in [ 1 .. Ngens( G )]]);
true
>
> Q, rels := ClassicalStandardPresentation( "SL" , 6, 4);
> #{Evaluate( r, E ) : r in rels} eq 1;
true
>
> g := Random( G );
> s := m1( g );
> s in SL(6,4);
true
> m2( s ) eq g;
true
>
> h := Random( SL( 6, 4 ) );
> g := m2( h );
> g in G;
true
> m1( g ) eq h;
false
> IsScalar( m1( g ) * h^-1 );
true
>
> w := m3( g );
> w in WordGroup( G );
true
> m4( w ) eq g;
true
> g eq Evaluate( w, [G.i : i in [ 1 .. Ngens( G )]]);
true
```
##### `ClassicalChangeOfBasis(G): GrpMat[FldFin] -> GrpMatElt[FldFin]`
Let $G$ be a classical group in its natural representation; return a change-of-basis matrix to conjugate the generators returned by `ClassicalStandardGenerators` to those returned by `ClassicalConstructiveRecognition` $(G)$. The latter intrinsic must have been applied to $G$.
##### `ClassicalRewrite(G, gens, type, dim, q, g : parameters): Grp, SeqEnum, MonStgElt, RngIntElt, RngIntElt, GrpElt -> BoolElt, GrpElt`
```magma
Method: MonStgElt Default: "choose"
```
Let $G$ be a classical group of type `type`, which is one of the strings “SL”, “Sp”, “SU”, “Omega”, “Omega-”, or “Omega+”, with dimension `dim` over the field ${\bf F}_{q}$ generated by `gens` which satisfy `ClassicalStandardPresentation (type, dim, q)`. Further, let $g$ be an element of `Generic`$(G)$.
If $g \in G$, then the function returns `true` and an SLP for $g$ in `gens`; if $g\not\in G$ then the function searches for an SLP $w$ such that $g \cdot$`Evaluate`$(w, gens)^{-1}$ centralizes $G$; if it is successful, it returns `false` and $w$. Otherwise the function returns `false, false`.
The function chooses one of the following methods:
**(i)**
If $G$ is in its natural representation and `gens` is `ClassicalStandardGenerators (type, dim, q)` then an algorithm of Costi [[Cos09](https://docs.magma-maths.org/references.md#cite-costi-phd)] is used.
**(ii)**
If (i) is not valid, but $G$ is an absolutely irreducible representation in the defining characteristic, then an algorithm of Costi [[Cos09](https://docs.magma-maths.org/references.md#cite-costi-phd)] is used.
**(iii)**
If neither of (i) and (ii) is valid, then a “black-box” method, independent of the representation of $G$, developed by Csaba Schneider is used.
The optional parameter `Method` can be used to override the default choice of method. The possible values of `Method` are `CharP` and `BB`.
A description of the algorithm used in the defining characteristic case appears in [[Cos09](https://docs.magma-maths.org/references.md#cite-costi-phd)]; a short description of the black-box algorithm appears in [[AMPS10a](https://docs.magma-maths.org/references.md#cite-ambroseetal)].
The code was developed and written by Csaba Schneider.
##### `ClassicalRewriteNatural(type, CB, g): MonStgElt, GrpMatElt, GrpMatElt -> BoolElt, GrpElt`
##### `ClassicalRewriteNatural(G, type, CB, g): MonStgElt, GrpMatElt, GrpMatElt -> BoolElt, GrpElt`
This is a faster specialized version of the intrinsic `ClassicalRewrite` discussed above; it is designed for classical groups in their **natural representation**.
The argument `type` must be one of the strings “SL”, “Sp”, “SU”, “Omega”, “Omega-”, or “Omega+”. Both `CB` and $g$ are elements of some ${\operatorname{GL}}(d, q)$.
If $g$ is a member of the group generated by `ClassicalStandardGenerators (type, d, q)`$^{{\tt CB}}$ then the function returns `true` and an SLP $w$ such that `Evaluate (w, ClassicalStandardGenerators (type, d, q)`$^{{\tt CB}}) = g$. Otherwise the function returns `false, false`.
If many elements of the same group $G$ are rewritten in terms of standard generators, then the second signature with $G$ as an argument is recommended on efficiency grounds since the results of some necessary precomputations are stored in $G$.
This algorithm, based on that developed by Elliot Costi [[Cos09](https://docs.magma-maths.org/references.md#cite-costi-phd)], was implemented by Csaba Schneider.
##### `ClassicalStandardPresentation(type, d, q : parameters): MonStgElt, RngIntElt, RngIntElt -> SLPGroup, []`
```magma
Projective: BoolElt Default: false
```
Given the specification `type, d, q` of a quasisimple group $G$, this intrinsic constructs a presentation on the standard generators for $G$. The string `type` must be one of “SL”, “Sp”, “SU”, “Omega”, “Omega-”, or “Omega+”, while $d$ is the dimension and $q$ is the cardinality of the finite field. The presentations are described in [[LGO20](https://docs.magma-maths.org/references.md#cite-lgo-pres)]. The relations are returned as SLPs together with the parent SLPGroup.
If the parameter `Projective` is set to true, the intrinsic constructs a presentation for the corresponding projective group.
##### `Example: Standard Generators for SL(6, 125) (ex-7ccc3b)`
As our first illustration, we produce standard generators for ${\operatorname{SL}}(6, 5^3)$:
```magma
> E := ClassicalStandardGenerators ("SL", 6, 5^3);
> E;
[
[ 0 1 0 0 0 0]
[ 4 0 0 0 0 0]
[ 0 0 1 0 0 0]
[ 0 0 0 1 0 0]
[ 0 0 0 0 1 0]
[ 0 0 0 0 0 1],
[ 0 0 0 0 0 1]
[ 4 0 0 0 0 0]
[ 0 4 0 0 0 0]
[ 0 0 4 0 0 0]
[ 0 0 0 4 0 0]
[ 0 0 0 0 4 0],
[ 1 1 0 0 0 0]
[ 0 1 0 0 0 0]
[ 0 0 1 0 0 0]
[ 0 0 0 1 0 0]
[ 0 0 0 0 1 0]
[ 0 0 0 0 0 1],
[ $.1 0 0 0 0 0]
[ 0 $.1^123 0 0 0 0]
[ 0 0 1 0 0 0]
[ 0 0 0 1 0 0]
[ 0 0 0 0 1 0]
[ 0 0 0 0 0 1]
]
```
We now perform constructive recognition on ${\operatorname{SL}}(6, 5^3)$, and so obtain $S$, conjugate to $E$ in ${\operatorname{GL}}(6, 5^3)$. Observe that the change-of-basis matrix returned by `ClassicalChangeOfBasis` performs this conjugation.
```magma
> G := SL (6, 5^3);
> f, S, W := ClassicalConstructiveRecognition (G);
> f;
true
> CB := ClassicalChangeOfBasis (G);
> E^CB eq S;
true
```
Note that $W$ is list of SLPs expressing $S$ in terms of defining generators of $G$.
```magma
> S eq Evaluate (W, [G.i: i in [1..Ngens (G)]]);
true
```
We next express a random element of $G$ as a SLP in $S$ and then check that the standard generators satisfy the standard presentation.
```magma
> g := Random (G);
> f, w := ClassicalRewriteNatural ("SL", CB, g);
> Evaluate (w, S) eq g;
true
>
> P, R := ClassicalStandardPresentation ("SL", 6, 5^3);
> Set (Evaluate (R, S));
{
[ 1 0 0 0 0 0]
[ 0 1 0 0 0 0]
[ 0 0 1 0 0 0]
[ 0 0 0 1 0 0]
[ 0 0 0 0 1 0]
[ 0 0 0 0 0 1]
}
```
We perform constructive recognition on a random conjugate of ${\operatorname{Sp}}(10, 3^6)$ and again check that the standard generators satisfy the standard presentation.
```magma
> G := RandomConjugate (Sp(10, 3^6));
> f, S, W := ClassicalConstructiveRecognition (G);
> f;
true
```
The return variable $W$ is list of SLPs expressing $S$ in terms of defining generators of $G$.
```magma
> S eq Evaluate (W, [G.i: i in [1..Ngens (G)]]);
true
>
> g := Random (G);
> CB := ClassicalChangeOfBasis (G);
> f, w := ClassicalRewriteNatural ("Sp", CB, g);
> Evaluate (w, S) eq g;
true
>
> P, R := ClassicalStandardPresentation ("Sp", 10, 3^6);
> Set (Evaluate (R, S));
{
[1 0 0 0 0 0 0 0 0 0]
[0 1 0 0 0 0 0 0 0 0]
[0 0 1 0 0 0 0 0 0 0]
[0 0 0 1 0 0 0 0 0 0]
[0 0 0 0 1 0 0 0 0 0]
[0 0 0 0 0 1 0 0 0 0]
[0 0 0 0 0 0 1 0 0 0]
[0 0 0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 0 0 1 0]
[0 0 0 0 0 0 0 0 0 1]
}
```
As another demonstration, we constructively recognise $\Omega^{-}(16, 2^6)$.
```magma
> G := RandomConjugate (OmegaMinus (16, 2^6));
> f, S, W := ClassicalConstructiveRecognition (G);
> f;
true
```
A random element of $G$ is expressed as an SLP in $S$:
```magma
> g := Random (G);
> CB := ClassicalChangeOfBasis (G);
> f, w := ClassicalRewriteNatural ("Omega-", CB, g);
> Evaluate (w, S) eq g;
true
```
Finally, we illustrate using `ClassicalRewrite` to write an element of a classical group in a non-natural representation as an SLP in its standard generators.
```magma
> gens := [ExteriorSquare (x) : x in ClassicalStandardGenerators ("Sp", 6, 25)];
> G := sub;
> x := Random (G);
> f, w := ClassicalRewrite (G, gens, "Sp", 6, 25, x);
> f;
true
> Evaluate (w, gens) eq x;
true
> f, w := ClassicalRewrite (G, gens, "Sp", 6, 25, x : Method := "BB");
> f;
true
> Evaluate (w, gens) eq x;
true
```
#### Constructive Recognition for Exceptional Groups
Here we discuss machinery for constructive recognition of most of the finite exceptional groups. For the remainder, see `RecogniseSz`, `RecogniseRee`, and `RecogniseLargeRee`.
##### `ExceptionalStandardGenerators(type, rank, q): MonStgElt, RngIntElt, RngIntElt -> []`
Return standard generators for the finite exceptional simple group of specified type `type` and rank `rank` over a field of size $q$. The type is designated by the argument `type` which must be one of the strings “E”, “F”, “G”, “2E”, “3D”. The standard generators, $X$ and $X_m$, are defined in [[LO16](https://docs.magma-maths.org/references.md#cite-exceptional-lob16)]; they label the positive and negative root groups of the group respectively and satisfy the presentation returned by `ExceptionalStandardPresentation`. The copy of the exceptional group generated by $X$ and $X_m$ is that defined in [[HRT01](https://docs.magma-maths.org/references.md#cite-howlett-rylands-taylor)]. This function is essentially a wrapper for `CST_Generators` prepared by Don Taylor.
```magma
> X, Xm := ExceptionalStandardGenerators ("F", 4, 5^3);
> #X;
8
> #X[1];
3
> X, Xm := ExceptionalStandardGenerators ("2E", 6, 3^4);
> #X;
8
> #X[1];
4
```
##### `ExceptionalConstructiveRecognition(G, type, rank, q): GrpMat[FldFin], MonStgElt, RngIntElt, RngIntElt -> BoolElt, Map, Map, Map, Map, SeqEnum, SeqEnum`
The input group $G = \langle Y \rangle$ is a matrix group defined over a finite field. It must be isomorphic to a central quotient of an exceptional group of specified type `type` and rank `rank` over a field of size $q$. The type is designated by the argument `type` which must be one of the strings “E”, “F”, “G”, “2E”, “3D”. The function constructs standard generators for $G$. If it is successful, then return `true`; four maps $m_1, m_2, m_3, m_4$; the standard generators $E$ for $G$; and their SLPs $W$ in $Y$; otherwise return `false`. The map $m_1$ is from $G$ to the standard copy $S$ of $G$; the map $m_2$ is from $S$ to $G$; the map $m_3$ is from $G$ to `WordGroup(G)`; the map $m_4$ is from `WordGroup(G)` to $G$. Since, in general, $G$ is isomorphic to a central quotient of $S$, the maps $m_1$ and $m_2$ are homomorphisms modulo scalars. The maps $m_1$, $m_2$, and $m_3$ are returned only if $G$ is a defining characteristic absolutely irreducible matrix representation of the exceptional group. The standard generators $E$ are returned as a sequence of length 2: its entries, $X$ and $X_m$, label the positive and negative root groups respectively.
The algorithm used is that of [[LO16](https://docs.magma-maths.org/references.md#cite-exceptional-lob16)]; the implementation was developed by Eamonn O’Brien. The maps $m_1$, $m_2$, and $m_3$ are provided by `ExceptionalRewrite`, developed and implemented by Don Taylor.
The verbose flag `SetVerbose("Except", 1)` may be used to print information on the progress of the function.
##### `Example: Constructive Recognition of an Exceptional Group (ex-111a3c)`
We illustrate these functions with two examples.
```magma
> G := MatrixGroup ("G25", 6);
> G: Minimal;
MatrixGroup(27, GF(5)) of order 2^6 * 3^3 * 5^6 * 7 * 31
> f, m1, m2, m3, m4, E, W := ExceptionalConstructiveRecognition( G, "G", 2, 5 );
> Q, R := ExceptionalStandardPresentation ("G", 2, 5);
> X := E[1]; Xm := E[2];
> #Set (Evaluate( R, &cat X cat &cat Xm)) eq 1;
true
> x := Random (G);
> m1;
Mapping from: GL(27, GF(5)) to GL(7, GF(5)) given by a rule [no inverse]
> y := m1 (x);
> m3;
Mapping from: GL(27, GF(5)) to SLPGroup(2) given by a rule [no inverse]
> w := m3 (x);
> Evaluate (w, [G.i: i in [1..Ngens (G)]]) eq x;
true
> &cat X eq Evaluate( &cat W[1], [G.i : i in [ 1 .. Ngens( G )]]);
true
> &cat Xm eq Evaluate( &cat W[2], [G.i : i in [ 1 .. Ngens( G )]]);
true
>
> G := ChevalleyGroup ("3D", 4, 4);
> G := RandomConjugate (G);
> G: Minimal;
MatrixGroup(8, GF(2^6))
> f, m1, m2, m3, m4, E, W := ExceptionalConstructiveRecognition( G, "3D", 4, 4);
> Q, R := ExceptionalStandardPresentation ("3D", 4, 4);
> X := E[1]; Xm := E[2];
> #Set (Evaluate( R, &cat X cat &cat Xm)) eq 1;
true
```
##### `ExceptionalRewrite(type, rank, q, X, Xm, g): MonStgElt, RngIntElt, RngIntElt, SeqEnum, SeqEnum, GrpElt -> BoolElt, GrpElt`
Let $G$ be a finite exceptional group of type `type` and rank `rank` over a field of size $q$. The type is designated by the argument `type` which must be one of the strings “E”, “F”, “G”, “2E”, “3D”. Also $X$ and $X_m$ are generators which satisfy `ExceptionalStandardPresentation (type, rank, q)`. Further, let $g$ be an element of `Generic`$(G)$.
If $g \in G$, then the function returns `true` and an SLP for $g$ in `&cat X cat &cat Xm`; if $g\not\in G$ then the function searches for an SLP $w$ such that $g \cdot$ `Evaluate`(`w, &cat X cat &cat Xm`)$^{-1}$ centralizes $G$; if it is successful, it returns `false` and $w$. Otherwise the function returns `false, false`.
A description of the algorithm used appears in [[CMT04](https://docs.magma-maths.org/references.md#cite-cohenmurraytaylor), [CT19](https://docs.magma-maths.org/references.md#cite-cohen-taylor-preprint)]. This function is essentially a wrapper for `LieTypeRewrite` prepared by Don Taylor.
```magma
> g := Random (G);
> f, w := ExceptionalRewrite ("G", 2, 5, X, Xm, g);
> f;
true
> g eq Evaluate (w, &cat X cat &cat Xm);
true
```
##### `ExceptionalStandardPresentation(type, rank, q): MonStgElt, RngIntElt, RngIntElt -> SLPGroup, []`
Let $G$ be a finite exceptional group of type `type` and rank `rank` defined over a field of size $q$. The type is designated by the argument `type` which must be one of the strings “E”, “F”, “G”, “2E”, “3D”. This intrinsic constructs a presentation on the standard generators for $G$. The relations are returned as SLPs together with the parent SLPGroup. The standard presentations returned by this function are listed explicitly in [[LO16](https://docs.magma-maths.org/references.md#cite-exceptional-lob16)]. This function is essentially a wrapper for `CST_Presentation` prepared by Don Taylor.
`ExceptionalStandardGenerators` returns matrices satisfying this presentation. `ExceptionalConstructiveRecognition` constructs such generators in an arbitrary matrix representation $G$.
##### `Example: Standard Presentation of G2 (ex-b84999)`
```magma
> Q, R := ExceptionalStandardPresentation ("G", 2, 5^3);
> X, Xm := ExceptionalStandardGenerators ("G", 2, 5^3);
> #Set (Evaluate (R, &cat X cat &cat Xm));
1
> G := ChevalleyGroup ("G", 2, 5^3);
> G := RandomConjugate (ExteriorSquare (G));
> G:Minimal;
MatrixGroup(21, GF(5^3))
> f, m1, m2, m3, m4, E, W := ExceptionalConstructiveRecognition(G, "G",
> 2, 5^3);
> X := E[1]; Xm := E[2];
> #Set (Evaluate (R, &cat X cat &cat Xm));
1
```
### Composition Trees for Matrix Groups
#### The Composition Tree Algorithm
A *composition tree* for a group $G$ can be viewed as a data structure which presents a group in terms of its composition factors. The tree is constructed recursively and the data structure facilitates the rewriting of elements of $G$ in terms of different generating sets.
The basic strategy for computing a *composition tree* of a matrix group employs a combination of a constructive version of Aschbacher’s theorem [[Asc84](https://docs.magma-maths.org/references.md#cite-asch-maximal-subgps)] and constructive recognition algorithms for finite simple groups. The basic algorithms are described in [[LG01](https://docs.magma-maths.org/references.md#cite-crlg01), [OBr06](https://docs.magma-maths.org/references.md#cite-obrien-survey), [OBr11](https://docs.magma-maths.org/references.md#cite-obrien10)] while some new ideas introduced in [[NS06](https://docs.magma-maths.org/references.md#cite-neunhoeffer-seress)] are incorporated. A detailed account of the entire [`CompositionTree`](https://docs.magma-maths.org/search.html?q=CompositionTree&show=intrinsics&match=exact) procedure appears in [[BHLGO15](https://docs.magma-maths.org/references.md#cite-baarnhielmetal11)].
The algorithm for constructing a composition tree for a group $G$ proceeds as follows.
**(i)**
Attempt to construct an effective homomorphism $\phi : G \to G_1$, for some group $G_1$. The homomorphism $\phi$ is called a *reduction* of $G$ since $G_1$ is “smaller” than $G$ in some sense – for example, with respect to its degree or field of definition.
**(ii)**
Otherwise deduce that $G$ is cyclic, elementary abelian, or “close” to being non-abelian simple. In this case $G$ becomes a *leaf* in the tree.
If Case (i) applies the algorithm proceeds as follows:-
1. Construct a composition tree for $G_1$.
2. Determine generators for $G_0 := {\rm Ker}(\phi)$. This requires a rewriting algorithm for $G_1$.
3. Construct a composition tree for $G_0$.
4. Combine the composition trees for $G_1$ and $G_0$ to produce a composition tree for $G$.
If $G \leq {\operatorname{GL}}(d, q)$, then Aschbacher’s theorem [[Asc84](https://docs.magma-maths.org/references.md#cite-asch-maximal-subgps)] is applied in Step (1). This requires algorithms that can decide whether $G$ lies in a certain Aschbacher class, and to construct the corresponding $\phi$. Other homomorphisms, such as the determinant map, may also be used.
The group associated with a leaf need not be simple. It may be cyclic or elementary abelian, a soluble or non-abelian simple primitive permutation group, or an absolutely irreducible matrix group that is simple modulo its centre. The decision on just which groups are treated as leaves is partly dictated by complexity considerations, and partly based on the quality of available algorithms for processing a leaf. For example, refining a cyclic group into its composition factors appears to offer no practical advantage.
Once a composition tree for $G = \langle X \rangle$ has been constructed, then a second list $Y$ of *nice generators* are stored with $G$. The group $\langle Y \rangle$ is called the *nice group*. The intrinsic `CompositionTree` constructs the nice generators $Y$ as straight-line programs (SLPs) with respect to $X$. The rewriting algorithm solves rewriting problems with respect to $Y$ and the resulting SLPs can then be rewritten to provide SLPs on $X$.
The verbose flag `SetVerbose("CompositionTree", n)` with $n=1, \ldots, 10$ may be used to print increasing levels of information on the progress of the functions.
#### Constructing the Composition Tree
##### `CompositionTree(G): GrpMat[FldFin] -> []`
Let $G$ be a finite group generated by matrices over a finite field. The intrinsic constructs a composition tree for $G$ using the algorithm outlined at the beginning of this section. The tree is returned as the value of this intrinsic and is also stored with $G$ and it is usually accessed by reference to $G$.
The intrinsic has a number of parameters that are described below. Even in the case of a small group, the tree is a very voluminous object so that information about it should be extracted using the intrinsics described below. The tree is constructed using Monte Carlo algorithms and so there is a small probability that it is incorrect. Algorithms are available to verify the correctness of the tree and may be invoked either by setting a parameter for the `CompositionTree` intrinsic or by a separate intrinsic `CompositionTreeVerify` that may be applied to the tree produced by a call to `CompositionTree` and which is described below.
##### `Example: Composition Tree for J4 (ex-009621)`
The minimum degree of a permutation representation of the sporadic simple group $J_4$ is $173,067,389$ while there is a matrix representation of degree $112$ over the finite field $F_2$. We extract this matrix representation of $J_4$ from the Atlas database and apply `CompositionTree` to it.
```magma
> G := MatrixGroup(AtlasGroup("J4"));
> G:Minimal;
MatrixGroup(112, GF(2))
> time G_Tree := CompositionTree(G);
Time: 3.030
```
We now extract the order and list the isomorphism types of the non-abelian composition trees.
```magma
> CompositionTreeOrder(G);
86775571046077562880
> nafact := CompositionTreeNonAbelianFactors(G);
> nafact[1][3];
"J4"
```
##### `CompositionTree(G : parameters): GrpMat[FldFin] -> []`
```magma
Verify : BoolElt Default: false
Scalar : FldFinElt Default: 1
KernelBatchSize : RngIntElt Default: 5
MandarinBatchSize : RngIntElt Default: 100
MaxHomFinderFails : RngIntElt Default: 1
MaxQuotientOrder : RngIntElt Default: 10^6
FastTensorTest : BoolElt Default: true
MaxBSGSVerifyOrder: RngIntElt Default: 2000
AnalysePermGroups : BoolElt Default: false
KnownLeaf : BoolElt Default: false
NamingElements : RngIntElt Default: 200
UnipotentBatchSize: RngIntElt Default: 100
PresentationKernel: BoolElt Default: true
```
Let $G$ be a finite group generated by matrices over a finite field. The intrinsic constructs a composition tree for $G$ and returns the tree using the algorithm outlined at the beginning of this section. The intrinsic has a number of parameters which are now described.
`Verify`: If `true`, then verify correctness of the tree during construction.
`KernelBatchSize`: The number of normal generators used to construct the kernel of homomorphism.
`MandarinBatchSize`: The number of random elements used to check correctness of the outcome of Monte-Carlo algorithms.
`MaxHomFinderFails`: Assume a negative answer after `MaxHomFinderFails` failures of certain Monte Carlo algorithms.
`MaxQuotientOrder`: A leaf with larger order will not be fully refined to its composition factors.
`FastTensorTest`: Use only the fast tensor product test.
`MaxBSGSVerifyOrder`: If `RandomSchreier` is used on a leaf and it has order less than `MaxBSGSVerifyOrder`, then `Verify` the calculation.
`AnalysePermGroups`: If `false`, then always treat the permutation group as a leaf, and do not analyse its structure.
`NamingElements:` The number of random elements used in calls to `LieType` and `RecogniseClassical`.
`PresentationKernel`: Use presentations to obtain kernels, where possible.
`UnipotentBatchSize`: Batch size for the unipotent kernels.
##### `CompositionTreeFastVerification(G): Grp -> BoolElt`
The argument $G$ must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. The intrinsic determines if correctness of the composition tree can be verified at modest cost using presentations. In effect, the intrinsic determines whether presentations on nice generators are known for all the leaves.
##### `CompositionTreeVerify(G): Grp -> BoolElt, []`
The argument $G$ must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. The intrinsic verifies the correctness of the composition tree by using it to construct a presentation for $G$. If $G$ satisfies the presentation, then return `true`, and the relators of the presentation as SLPs; otherwise return `false`. The presentation is on the group returned by `CompositionTreeNiceGroup`$(G)$.
##### `Example: Verifying a Composition Tree (ex-1c147a)`
We use the two methods of establishing correctness to verify the result of applying `CompositionTree` to a wreath product.
```magma
> U33 := MatrixGroup(AtlasGroup("U33"), 1);
> G := TensorWreathProduct( U33, Sym(3) );
> time G_Tree := CompositionTree(G);
Time: 26.620
```
```magma
> G := TensorWreathProduct( U33, Sym(3) );
> time G_Tree := CompositionTree(G : Verify := true);
Time: 28.450
```
Thus, verification adds a little under $2$ seconds to the runtime.
```magma
> G := TensorWreathProduct( U33, Sym(3) );
> time G_Tree := CompositionTree(G );
Time: 26.620
> time CompositionTreeFastVerification(G);
Time: 0.000
true
> time CompositionTreeVerify(G);
Time: 1.850
true
```
In this case we use `CompositionTreeFastVerification` to check that verification wont be expensive and then apply the intrinsic `CompositionTreeVerify` to actually do the verification. Again, it takes less than $2$ seconds.
#### Accessing the Composition Tree
##### `CompositionTreeOrder(G): Grp -> RngIntElt`
The argument $G$ must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. This intrinsic returns the order of $G$.
##### `CompositionTreeNonAbelianFactors(G): Grp -> RngIntElt`
The argument $G$ must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. The intrinsic returns the isomorphism types of the non-abelian composition factors of $G$ as a sequence of triples where each triple defines an isomorphism type.
##### `DisplayCompTreeNodes(G : parameters): Grp`
```magma
NonTrivial: BoolElt Default: true
Leaves : BoolElt Default: false
```
The argument $G$ must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. This intrinsic displays information about the nodes in the composition tree for $G$. The tree is traversed in-order. If parameter `NonTrivial` is `true`, then only non-trivial nodes will be displayed. If parameter `Leaves` is `true` then only leaves will be displayed.
##### `Example: Subgroup Order and Membership in J4 (ex-8acf9e)`
The composition tree (CT) machinery allows us to create a subgroup $H$ of a group $G$ with a CT, to determine the order of $H$, and to test membership in $H$. In general, additional machinery is needed in order to be able to determine information about the subgroup structure of $G$. However, there are two Monte Carlo algorithms for computing subgroups, specifically, an algorithm for computing the centralizer of an involution and an algorithm for computing the normal closure of a subgroup. We illustrate how the centralizer algorithm can be used by applying it to compute a large subgroup in the sporadic group $J_4$. The group $J_4$ has a maximal subgroup of order 21,799,895,040 which is the centralizer of an involution. We will try to find this maximal subgroup by working with $J_4$ in its matrix representation of degree 112 over $GF(2)$.
```magma
> G := MatrixGroup(AtlasGroup("J4"));
> G:Minimal;
MatrixGroup(112, GF(2))
> CT := CompositionTree(G);
> CompositionTreeOrder(G);
86775571046077562880
> found := false;
> for i := 1 to 30 do
> bool, x := RandomElementOfOrder(G, 2);
> C := CentraliserOfInvolution(G, x);
> CTree := CompositionTree(C);
> n := CompositionTreeOrder(C);
> if n eq 21799895040 then
> found := true;
> break;
> end if;
> end for;
> found;
true
> CompositionTreeOrder(C);
21799895040
```
Our random search has produced a subgroup of the right order. We now display part of the composition tree in order to get an idea of the group structure of $C$.
```magma
> DisplayCompTreeNodes(C : Leaves := true);
node = 6
parent = 5
depth = 5
scalar = 1
info = leaf, GrpPerm, RandomSchreier, order 2
fast verify = true
----------
node = 7
parent = 5
depth = 5
scalar = 1
info = leaf, GrpMat, almost simple, <18, 3, "M22">
fast verify = true
----------
node = 15
parent = 14
depth = 11
scalar = 1
info = leaf, GrpAb, abelian group, order 3
fast verify = true
----------
node = 25
parent = 24
depth = 3
scalar = 1
info = leaf, GrpAb, abelian group, order 16
fast verify = true
----------
node = 27
parent = 26
depth = 4
scalar = 1
info = leaf, GrpAb, abelian group, order 256
fast verify = true
----------
node = 29
parent = 28
depth = 5
scalar = 1
info = leaf, GrpAb, abelian group, order 2
fast verify = true
----------
```
From this information we deduce that structure of the subgroup is consistent with $2^{1+12}.3.M_{22}.2$ which is the structure of the second largest maximal subgroup of $J_4$.
##### `CompositionTreeNiceGroup(G): Grp -> GrpMat[FldFin]`
The argument $G$ must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. The intrinsic returns the nice group for $G$.
##### `CompositionTreeSLPGroup(G): Grp -> GrpSLP, Map`
The argument $G$ must be a matrix group over a finite field for which a composition tree datastructure and the associated nice group $H$ has previously been constructed. The intrinsic returns the word group $W$ for $H$, and the map from $W$ to $H$.
##### `CompositionTreeNiceToUser(G): Grp -> Map, []`
The argument $G$ must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. This intrinsic returns the coercion map from SLPs in nice generators of $G$ to SLPs in input user generators of $G$, as well as the SLPs of the nice generators given in terms the user generators.
##### `CompositionTreeOrder(G): Grp -> RngIntElt`
##### `CompositionTreeFactoredOrder(G): Grp -> RngIntEltFact`
The argument $G$ must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. The intrinsics return the (factored) order of $G$.
##### `CompositionTreeElementToWord(G, g): Grp, GrpElt -> BoolElt, GrpSLPElt`
The argument $G$ must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. Given an element $g\in G$, return `true` and an SLP for $g$ in the nice generators of $G$, otherwise return `false`.
##### `CompositionTreeNonAbelianFactors(G): GrpMat[FldFin] -> List`
The argument $G$ must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. This intrinsic returns a list naming the non-abelian composition factors of $G$.
##### `CompositionTreeCBM(G): GrpMat[FldFin] -> GrpMatElt`
The argument $G$ must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. This intrinsic returns a change-of-basis matrix that exhibits the Aschbacher reductions of $G$ given by the composition tree.
##### `CompositionTreeReductionInfo(G, t): Grp, RngIntElt -> MonStgElt, Grp, Grp`
The argument $G$ must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. This intrinsic returns a string description of the reduction at the internal node $t$ in the composition tree for $G$, as well as the image and kernel of this reduction.
##### `CompositionTreeSeries(G): Grp -> SeqEnum, List, List, List, BoolElt, []`
The argument $G$ must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. This intrinsic returns:
1. A normal series of subgroups $1 = G_0 < G_1 < ... < G_k = G$.
2. Maps $G_i \mapsto S_i$, where $S_i$ is the standard copy of $G_i / G_{i-1}$, where $i \geq 1$. The kernel of this map is $G_{i-1}$. Observe that $S_i$ may be the standard copy plus scalars $Z$, and the map is then a homomorphism modulo scalars, so that the kernel is $(G_{i-1}.Z)/Z$.
3. Maps $S_i \mapsto G_i$.
4. Maps $S_i \mapsto$ `WordGroup`$(S_i)$.
5. Boolean flag `true` or `false` to indicate if the series is a true composition series.
6. A sequence of the leaf nodes in the composition tree corresponding to each composition factor. All maps are defined by rules, so `Function` can be applied on them to avoid built-in membership testing.
##### `CompositionTreeFactorNumber(G, g): Grp, GrpElt -> RngIntElt`
The argument $G$ must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. This intrinsic returns the minimal integer $i$ such that $g$ lies in the $i$th-term of the normal series returned by `CompositionTreeSeries` for $G$.
##### `HasCompositionTree(G): Grp -> BoolElt`
Given a matrix group $G$ defined over a finite field, this intrinsic returns `true` if $G$ has a composition tree and `false` otherwise.
##### `CleanCompositionTree(G): Grp`
The argument $G$ must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. This intrinsic removes all data related to the composition tree datastructure for $G$.
##### `Example: Composition Tree of a Conformal Orthogonal Group (ex-0bfaff)`
A composition tree for the conformal orthogonal group $G$ of plus type of degree $4$ over ${\bf F}_{5^2}$ will be constructed.
```magma
> G := CGOPlus(4, 5^2);
>
> T := CompositionTree(G);
>
> DisplayCompTreeNodes (G: Leaves:=true);
node = 2
parent = 1
depth = 1
scalar = 1
info = leaf, GrpAb, cyclic group, order 12
fast verify = true
----------
node = 4
parent = 3
depth = 2
scalar = 1
info = leaf, GrpAb, cyclic group, order 4
fast verify = true
----------
node = 7
parent = 6
depth = 4
scalar = 12
info = leaf, GrpAb, cyclic group, order 24
fast verify = true
----------
node = 8
parent = 6
depth = 4
scalar = 2
info = leaf, GrpMat, almost simple, <"A", 1, 25>
fast verify = true
----------
node = 9
parent = 5
depth = 3
scalar = 1
info = leaf, GrpMat, almost simple, <"A", 1, 25>
fast verify = true
----------
```
Next the correctness of the composition tree is verified. In order to demonstrate what is going on, various pieces of the verification process will be examined. Firstly, the nice group H for G and its associated SLP group, is set up; observe that $H = G$. After checking that verification can be carried out quickly, the verification is actually performed.
```magma
> H := CompositionTreeNiceGroup(G);
> W := CompositionTreeSLPGroup(G);
>
> CompositionTreeFastVerification(G);
true
>
> f, R := CompositionTreeVerify(G);
```
At this point correctness has been verified. To show what verification actually involves, the relations $R$ on the generators of $H$ will be explicitly evaluated. This step has already been performed by `CompositionTreeVerify` and is shown here just for demonstration purposes.
```magma
> Set(Evaluate(R, [H.i:i in [1..Ngens(H)]]));
{
[ 1 0 0 0]
[ 0 1 0 0]
[ 0 0 1 0]
[ 0 0 0 1]
}
```
Knowing that the composition tree is correct, the order of $G$ is printed.
```magma
> CompositionTreeOrder(G);
11681280000
```
Express the element $g$ of $G$ as a SLP on the generators of the nice group $H$.
```magma
> g := Random(G);
> f, w := CompositionTreeElementToWord(G, g);
> Evaluate(w, [H.i:i in [1..Ngens(H)]]) eq g;
true
```
Rewrite the SLP in terms of the user-supplied generators for $G$.
```magma
> tau := CompositionTreeNiceToUser(G);
> tau;
Mapping from: GrpSLP: W to SLPGroup(5)
```
Images of elements of $W$ under $tau$ lie in `WordGroup`$(G)$.
```magma
> v := tau(w);
> Evaluate (v, [G.i : i in [1..Ngens(G)]]) eq g;
true
```
Test a random element of the generic group for $G$ for membership. (The generic group will be the general linear group ${\operatorname{GL}}(4, 5^2)$.)
```magma
> x := Random(Generic(G));
> f, w := CompositionTreeElementToWord(G, x);
> f;
false
```
Finally, we construct a normal series for $G$ and locate a random element within this series.
```magma
> CS, _, _, _, flag := CompositionTreeSeries(G);
> "Series is composition series? ", flag;
Series is composition series? true
> "Length is ", #CS;
Length is 10
>
> g := Random(G);
> CompositionTreeFactorNumber(G, g);
10
```
##### `Example: Composition Tree of a Maximal Subgroup (ex-b767f8)`
In this example, we choose a maximal subgroup of the linear group $SL(10, 2^8)$ and compute its composition tree.
```magma
> X := ClassicalMaximals ("L", 10, 2^8);
> G := X[1];
>
> T := CompositionTree (G);
>
> DisplayCompTreeNodes (G: Leaves:=true, NonTrivial:=true);
node = 6
parent = 5
depth = 5
scalar = 1
info = leaf, GrpAb, cyclic group, order 255
fast verify = true
----------
node = 9
parent = 8
depth = 5
scalar = 1
info = leaf, GrpMat, almost simple, <"A", 8, 256>
fast verify = true
----------
node = 13
parent = 12
depth = 3
scalar = 1
info = leaf, GrpPC, abelian group, order 256
fast verify = true
----------
node = 15
parent = 14
depth = 4
scalar = 1
info = leaf, GrpPC, abelian group, order 256
fast verify = true
----------
node = 17
parent = 16
depth = 5
scalar = 1
info = leaf, GrpPC, abelian group, order 256
fast verify = true
----------
node = 19
parent = 18
depth = 6
scalar = 1
info = leaf, GrpPC, abelian group, order 256
fast verify = true
----------
node = 21
parent = 20
depth = 7
scalar = 1
info = leaf, GrpPC, abelian group, order 256
fast verify = true
----------
----------
node = 23
parent = 22
depth = 8
scalar = 1
info = leaf, GrpPC, abelian group, order 256
fast verify = true
----------
node = 25
parent = 24
depth = 9
scalar = 1
info = leaf, GrpPC, abelian group, order 256
fast verify = true
----------
node = 27
parent = 26
depth = 10
scalar = 1
info = leaf, GrpPC, abelian group, order 256
fast verify = true
----------
node = 29
parent = 28
depth = 11
scalar = 1
info = leaf, GrpPC, abelian group, order 256
fast verify = true
----------
```
We now set up the nice group $H$ for $G$ and its associated SLP group; observe that $H = G$.
```magma
> H := CompositionTreeNiceGroup(G);
> "# of generators of H is ", Ngens(H);
# of generators of H is 77
> W := CompositionTreeSLPGroup(G);
```
After checking that correctness of the composition tree can be verified quickly, we perform verification.
```magma
> CompositionTreeFastVerification(G);
true
> f, R := CompositionTreeVerify(G);
```
Evaluate the relations on the generators of $H$.
```magma
> Set (Evaluate (R, [H.i:i in [1..Ngens (H)]]));
{
[1 0 0 0 0 0 0 0 0 0]
[0 1 0 0 0 0 0 0 0 0]
[0 0 1 0 0 0 0 0 0 0]
[0 0 0 1 0 0 0 0 0 0]
[0 0 0 0 1 0 0 0 0 0]
[0 0 0 0 0 1 0 0 0 0]
[0 0 0 0 0 0 1 0 0 0]
[0 0 0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 0 0 1 0]
[0 0 0 0 0 0 0 0 0 1]
}
```
Express the element $g$ of $G$ as a SLP on the generators of the nice group $H$. Then rewrite the SLP in terms of user generators for $G$.
```magma
> g := Random (G);
> f, w := CompositionTreeElementToWord (G, g);
> Evaluate (w, [H.i:i in [1..Ngens (H)]]) eq g;
true
>
> tau := CompositionTreeNiceToUser (G);
> tau;
Mapping from: GrpSLP: W to SLPGroup(4)
>
> v := tau (w);
> Evaluate (v, [G.i : i in [1..Ngens (G)]]) eq g;
true
```
Next test a random element of the generic group of $G$ for membership of $G$.
```magma
> x := Random (Generic (G));
> f, w := CompositionTreeElementToWord (G, x);
> f;
false
```
Finally, we construct a normal series for $G$.
```magma
> CS, _, _, _, flag := CompositionTreeSeries (G);
> "Series is composition series? ", flag;
Series is composition series? true
> "Length is ", #CS;
Length is 78
```
### The LMG functions
The LMG (large matrix group) functions are designed to provide a user-friendly interface to the `CompositionTree` package, and thereby enable the user to carry out a limited range of structural calculations in a matrix group that is too large for the use of BSGS methods.
By default, these methods have a small probability of failing or even of returning incorrect results. For most examples, at the cost of some extra time, the user can ensure that the computed results are verified as correct by calling `LMGInitialise` with the `Verify` flag on the group $G$ before calling any of the other functions. (Once `CompositionTree` or any of the LMG functions has been called on a group, further calls of `LMGInitialise` will have no effect.)
Let $G$ be a matrix group over a finite field. On the first call of any of the LMG functions on $G$, Magma decides whether it will use BSGS or Composition Tree based methods on $G$. It does this by carrying out a quick calculation to decide whether any of the basic orbit lengths would be larger than a constant `LMGSchreierBound`, which is set to 40000 by default, but can be changed by the user. If all basic orbit lengths are at most `LMGSchreierBound`, then BSGS methods are used on $G$, and the LMG functions are executed using the corresponding standard Magma functions. Otherwise, Composition Tree methods are used, starting with a call of `CompositionTree`$(G)$.
Composition Tree methods are also used if the user calls `CompositionTree` on the group before using th LMG functions, or if the user calls `LMGInitialize` with the `Al` option set to `"CompositionTree"`.
`SetVerbose("LMG", n)` with $n=1,2$ or 3 will provide increasing levels of information on the progress of the functions.
#### `SetLMGSchreierBound(n): RngIntElt`
Set the constant `LMGSchreierBound` to $n$.
#### `LMGInitialize(G : parameters): GrpMat`
#### `LMGInitialise(G : parameters): GrpMat`
```magma
Al : MonStgElt Default: ""
Verify : BoolElt Default: false
RandomSchreierBound: RngIntElt Default: LMGSchreierBound
```
It is not normally necessary to call this function but, by setting the optional parameters, it can be used to initialise $G$ for LMG computations with a different value of `LMGSchreierBound` or, by setting `Al` to be `"CompositionTree"` (or `"CT"` or `"RandomSchreier"` (or `"RS"`), to force the use of either Composition Tree or BSGS methods on $G$.
If the `Verify` flag is set, then an attempt will be made to verify the correctness of the computed BSGS or Composition Tree. This will make the initialisation process slower, and for some groups the increased memory requirements will make verification impractical. In that case, a warning message is displayed.
#### `LMGOrder(G): GrpMat[FldFin] -> RngIntElt`
Given a matrix group $G$ defined over a finite field, this intrinsic returns the order of $G$.
#### `LMGFactoredOrder(G): GrpMat[FldFin] -> SeqEnum`
Given a matrix group $G$ defined over a finite field, this intrinsic returns the factored order of $G$.
#### `LMGIsIn(G, x): GrpMat, GrpMatElt -> BoolElt, GrpSLPElt`
Given a matrix group $G$ defined over a finite field $\F_q$, and an element $x$ of the generic overgroup $\GL(n,q)$ of $G$; if $x \in G$ then the intrinsic returns `true` and the corresponding element of `WordGroup(G)`; and `false` otherwise.
#### `LMGIsSubgroup(G, H): GrpMat, GrpMat -> BoolElt`
Given a matrix group $G$ defined over a finite field $\F_q$, and a subgroup $H$ of the generic overgroup $\GL(n,q)$ of $G$, the intrinsic returns `true` if $H \le G$ and `false` otherwise.
#### `LMGEqual(G, H): GrpMat, GrpMat -> BoolElt`
Given a matrix groups $G$ and $H$ belonging to a common overgroup $\GL(n,q)$, the intrinsic returns `true` if $G$ and $H$ are equal and `false` otherwise.
#### `LMGIndex(G, H): GrpMat, GrpMat -> RngIntElt`
Given a matrix group $G$ defined over a finite field, and a subgroup $H$ of $G$, the intrinsic returns the index of $H$ in $G$.
#### `LMGIsNormal(G, H): GrpMat, GrpMat -> BoolElt`
Given a matrix group $G$ defined over a finite field, and a subgroup $H$ of $G$, the intrinsic returns `true` if $H$ is normal in $G$ and `false` otherwise.
#### `LMGNormalClosure(G, H): GrpMat, GrpMat -> GrpMat`
Given a matrix group $G$ defined over a finite field, and a subgroup $H$ of $G$, the intrinsic returns the normal closure of $H$ in $G$.
#### `LMGDerivedGroup(G): GrpMat -> GrpMat`
Given a matrix group $G$ defined over a finite field, the intrinsic returns the derived subgroup of $G$.
#### `LMGCommutatorSubgroup(G, H): GrpMat, GrpMat -> GrpMat`
Let $g$ and $H$ be subgroups of $\GL(n,q)$. This intrinsic returns the commutator subgroup of $G$ and $H$ as a subgroup of $\GL(n,q)$.
#### `LMGIsSoluble(G): GrpMat -> BoolElt`
#### `LMGIsSolvable(G): GrpMat -> BoolElt`
Given a matrix group $G$ defined over a finite field, the intrinsic returns `true` if $G$ is soluble and `false` otherwise.
#### `LMGIsNilpotent(G): GrpMat -> BoolElt`
Given a matrix group $G$ defined over a finite field, the intrinsic returns `true` if $G$ is nilpotent and `false` otherwise.
#### `LMGCompositionSeries(G): GrpMat[FldFin] -> SeqEnum`
Given a matrix group $G$ defined over a finite field, the intrinsic returns a composition series for $G$.
#### `LMGCompositionFactors(G): GrpMat[FldFin] -> SeqEnum`
Given a matrix group $G$ defined over a finite field, the intrinsic returns the composition factors of $G$. The Handbook entry for `CompositionFactors(G)` of a finite group gives a detailed description of how to interpret the returned sequence.
#### `LMGChiefSeries(G): GrpMat[FldFin] -> SeqEnum`
Given a matrix group $G$ defined over a finite field, the intrinsic returns a chief series for $G$.
#### `LMGChiefFactors(G): GrpMat[FldFin] -> SeqEnum`
Given a matrix group $G$ defined over a finite field, the intrinsic returns the chief factors $G$. The Handbook entry for `ChiefFactors(G)` of a finite group gives a detailed description of how to interpret the returned sequence.
#### `LMGUnipotentRadical(G): GrpMat -> GrpMat, GrpPC, Map`
Given a matrix group $G$ defined over a finite field, the intrinsic returns the unipotent radical $U$ of the matrix group $G$. A group $P$ of type `GrpPC` and an isomorphism $U \rightarrow P$ are also returned.
#### `LMGSolubleRadical(G): GrpMat -> GrpMat, GrpPC, Map`
#### `LMGSolvableRadical(G): GrpMat -> GrpMat, GrpPC, Map`
Given a matrix group $G$ defined over a finite field, the intrinsic returns the soluble radical $S$ of $G$. A group $P$ of type `GrpPC` and an isomorphism $S \rightarrow P$ are also returned.
#### `LMGFittingSubgroup(G): GrpMat -> GrpMat, GrpPC, Map`
Given a matrix group $G$ defined over a finite field, the intrinsic returns the Fitting subgroup $S$ of $G$. A group $P$ of type `GrpPC` and an isomorphism $S \rightarrow P$ are also returned.
#### `LMGCentre(G): GrpMat -> GrpMat`
#### `LMGCenter(G): GrpMat -> GrpMat`
Given a matrix group $G$ defined over a finite field, the intrinsic returns the centre of $G$.
#### `LMGSylow(G, p): GrpMat, RngIntElt -> GrpMat`
Given a matrix group $G$ defined over a finite field, the intrinsic returns a Sylow $p$-subgroup of $G$.
#### `LMGSocleStar(G): GrpMat -> GrpMat`
Given a matrix group $G$ defined over a finite field, the intrinsic returns the inverse image in $G$ of the socle of $G/S$, where $S$ is the soluble radical of $G$.
#### `LMGSocleStarFactors(G): GrpMat -> SeqEnum, SeqEnum`
Given a matrix group $G$ defined over a finite field, the intrinsic returns the simple direct factors of `LMGSocleStar(G)`/`LMGSolubleRadical(G)`, which may be represented projectively for large classical groups. A list of maps from the factors to $G$ is also returned.
#### `LMGSocleStarAction(G): GrpMat -> Map, GrpPerm, GrpMat`
Given a matrix group $G$ defined over a finite field, the intrinsic returns the map $\phi$ representing the conjugation action of $G$ on the simple direct factors of `LMGSocleStar(G)`/`LMGSolubleRadical(G)`. The image and kernel of $\phi$ are also returned.
#### `LMGSocleStarActionKernel(G): GrpMat -> GrpMat, GrpPC, Map`
Given a matrix group $G$ defined over a finite field, this intrinsic returns three values. The first is the kernel of the conjugation action of $G$ on the simple direct factors of `LMGSocleStar(G)`/`LMGSolubleRadical(G)`. A group $P$ of type `GrpPC` isomorphic to `LMGSocleStarActionKernel(G)`/`LMGSocleStar(G)` and the epimorphism $G \rightarrow P$ are also returned.
#### `LMGSocleStarQuotient(G): GrpMat -> GrpPerm, Map, GrpMat`
Given a matrix group $G$ defined over a finite field, the intrinsic returns the quotient group `G`/`LMGSocleStar(G)` represented as a permutation group, with associated epimorphism and kernel.
#### `Example: LMG Functions on a Maximal Subgroup (ex-533478)`
We apply the LMG functions to a maximal subgroup of ${\operatorname{SL}}(12, 5)$.
```magma
> SetVerbose("LMG", 1);
> C := ClassicalMaximals("L", 12, 5);
> G := C[4];
> LMGFactoredOrder(G);
RandomSchreierBound is 40000
Using CompositionTree on this group
Composition tree computed
Composition series has length 40
Order of group is: 27845944957511377275508129969239234924316406250000000000000\\
0000000000000000000
[ <2, 32>, <3, 7>, <5, 66>, <7, 1>, <11, 1>, <13, 3>, <31, 3>, <71, 1>, <313,
1>, <19531, 1> ]
> LMGChiefFactors(G);
Classifying composition factors
Defined PCGroup of solvable radical
Computed PCGroup of SocleKernel/SocleStar
G
| Cyclic(2)
*
| Cyclic(2)
*
| A(3, 5) = L(4, 5)
*
| A(7, 5) = L(8, 5)
*
| Cyclic(2)
*
| Cyclic(2)
*
| Cyclic(2)
*
| Cyclic(2)
*
| Cyclic(5) (32 copies)
1
> D := LMGDerivedGroup(G);
RandomSchreierBound is 40000
Using CompositionTree on this group
Composition tree computed
Composition series has length 38
Order of group is: 69614862393778443188770324923098087310791015625000000000000\\
000000000000000000
> LMGIndex(G, D);
4
> SetVerbose("LMG", 0);
> LMGEqual( LMGDerivedGroup(D), D );
true
> S := LMGSolubleRadical(G);
> LMGFactoredOrder(S);
[ <2, 4>, <5, 32> ]
> LMGIsSoluble(G);
false
> LMGIsSoluble(S);
true
> LMGIsNilpotent(S);
false
> #LMGCentre(G);
4
> #LMGCentre(S);
4
```
We carelessly used the standard Magma Order function in the above two commands, but it did not matter, because it was small. We will be more careful next time!
```magma
> F := LMGFittingSubgroup(G);
> LMGFactoredOrder( LMGCentre(F) );
[ <2, 2>, <5, 32> ]
> P := LMGSylow(G, 5);
> LMGFactoredOrder(P);
[ <5, 66> ]
> LMGEqual( D, LMGNormalClosure(G,P) );
true
> facs, maps := LMGSocleStarFactors(G);
> #facs;
2
> LMGChiefFactors(facs[1]);
G
| A(7, 5) = L(8, 5)
*
| Cyclic(2)
*
| Cyclic(2)
1
```
Note that, for large classical groups, the socle-star factors are represented projectively.
```magma
> I := sub< Generic(G) | [ facs[2].i @ maps[2] : i in [1..Ngens(facs[2])] ] >;
> LMGChiefFactors( LMGNormalClosure(G, I) );
G
| A(3, 5) = L(4, 5)
*
| Cyclic(2)
*
| Cyclic(2)
*
| Cyclic(2)
*
| Cyclic(2)
*
| Cyclic(5) (4 copies)
*
| Cyclic(5) (4 copies)
*
| Cyclic(5) (4 copies)
*
| Cyclic(5) (4 copies)
*
| Cyclic(5) (4 copies)
*
| Cyclic(5) (4 copies)
*
| Cyclic(5) (4 copies)
*
| Cyclic(5) (4 copies)
1
```
The remaining functions in this section will work only if a permutation representation can be computed for $G/L$, where $L$ is the soluble radical of $G$. Apart from `LMGRadicalQuotient` itself, they all operate by solving the problem first in $G/L$ and then lifting the solution through elementary abelian layers of $L$. Results are returned using the same formats as for other types of finite groups.
#### `LMGRadicalQuotient(G): GrpMat -> GrpPerm, Map, GrpMat`
Given a matrix group $G$ defined over a finite field, the intrinsic returns a permutation group $P$ isomorphic to $G/L$, where $L$ is the soluble radical of $G$. An epimorphism $G \to P$ and its kernel $L$ are also returned.
Of course, this will only work if $G/L$ has such a representation of sufficiently small degree. This function is called implicitly as a first step in all of the remaining functions in this section.
#### `LMGCentraliser(G, g): GrpMat, GrpMatElt -> GrpMat`
#### `LMGCentralizer(G, g): GrpMat, GrpMatElt -> GrpMat`
Given a matrix group $G$ defined over a finite field, the intrinsic returns the centraliser in the matrix group $G$ of $g \in G$.
#### `LMGIsConjugate(G, g, h): GrpMat, GrpMatElt, GrpMatElt -> BoolElt, GrpMatElt`
Given a matrix group $G$ defined over a finite field, the intrinsic returns `true` if the elements $g,h$ in $G$ are conjugate. If so, a conjugating element will also be returned.
#### `LMGClasses(G): GrpMat -> SeqEnum`
#### `LMGConjugacyClasses(G): GrpMat -> SeqEnum`
Given a matrix group $G$ defined over a finite field, the intrinsic returns the conjugacy classes of $G$.
#### `LMGNormaliser(G, H): GrpMat, GrpMat -> GrpMat`
#### `LMGNormalizer(G, H): GrpMat, GrpMat -> GrpMat`
Given a matrix group $G$ defined over a finite field, and a subgroup $H$ of $G$, the intrinsic returns the normaliser of $H$ in $G$.
#### `LMGIsConjugate(G, H, K): GrpMat, GrpMat, GrpMat -> BoolElt, GrpMatElt`
Given a matrix group $G$ defined over a finite field, and subgroups $H$ and $K$ of $G$, the intrinsic returns `true` if the subgroups $H$ and $K$ are conjugate in $G$. If so, a conjugating element will also be returned.
#### `LMGMeet(G, H, K): GrpMat, GrpMat, GrpMat -> GrpMat`
Given a matrix group $G$ defined over a finite field, and subgroups $H$ and $K$ of $G$, the intrinsic returns their intersection.
#### `LMGMaximalSubgroups(G): GrpMat -> SeqEnum`
Given a matrix group $G$ defined over a finite field, the intrinsic returns a list of subgroup records defining representatives of the conjugacy classes of maximal subgroups of $G$.
#### `LMGNormalSubgroups(G): GrpMat -> SeqEnum`
Given a matrix group $G$ defined over a finite field, the intrinsic returns a list of subgroup records defining the normal subgroups of $G$.
#### `LMGLowIndexSubgroups(G, n): GrpMat, RngIntElt -> SeqEnum`
Given a matrix group $G$ defined over a finite field, the intrinsic returns a list of representatives of the conjugacy classes of subgroups of index at most $n$ in $G$.
#### `LMGCosetAction(G, H : parameters): GrpMat, GrpMat -> Map, GrpPerm, GrpMat`
```magma
ker: BoolElt Default: true
```
Given a subgroup $H$ of a matrix group $G$ defined over a finite field, return the homomorphism $f:G \to P$ defining the action of $G$ by multiplication on the right cosets of $H$ in $G$. The image $P$ (a permutation group) and the kernel of $f$ are also returned.
If the optional parameter `ker` is set to `false` then the kernel of $f$ is not computed.
A right transversal of $H$ in $G$, in which the ordering corresponds to the order on the points permuted by $P$, is computed at the same time, and this can be accessed by calling `LMGRightTransversal(G,H : ca:=f)`.
#### `LMGCosetImage(G, H): GrpMat, GrpMat -> GrpPerm`
Given a subgroup $H$ of a matrix group $G$ defined over a finite field, return the image $P$ of the homomorphism $f:G \to P$ defining the action of $G$ by multiplication on the right cosets of $H$ in $G$.
#### `LMGCosetActionInverseImage(G, f, i): GrpMat, Map, RngIntElt -> GrpMatElt`
The map $f$ should be the result of a call of `LMGCosetAction` on some subgroup of the matrix group $G$. An element of $g \in G$ for which $1^{f(g)} = i$ is returned.
#### `LMGRightTransversal(G, H : parameters): GrpMat, GrpMat -> SeqEnum`
```magma
ca: Map Default:
```
Given a subgroup $H$ of a matrix group $G$ defined over a finite field, return a right transversal of $H$ in $G$. The optional parameter `ca` should be the map returned by `LMGCosetAction(G,H)`, and if this option is used then the elements in the transversal will be ordered in the same way as the points permuted by the image of `ca`.
#### `LMGIsPrimitive(G): GrpMat -> BoolElt`
Decide whether matrix group $G$ defined over a finite field is primitive.
#### `LMGCharacterTable(G : parameters): GrpMat -> SeqEnum`
Compute the character table of the matrix group $G$, using LMG functions for the calculations within the group. The overall method is as for the standard `CharacterTable` command.
#### `Example: Classes and Characters of the Dempwolff Group (ex-fa2be2)`
We apply the LMG classes and character table functions to the Dempwolff Group. We will use `LMGInitialize` to force use of the composition tree methods.
```magma
> G := MatrixGroup(ATLASGroup("25L52"));
> G:Minimal;
MatrixGroup(69, GF(2)) of order 2^15 * 3^2 * 5 * 7 * 31
> LMGInitialize(G:Al := "CT");
> LMGChiefFactors(G);
G
| A(4, 2) = L(5, 2)
*
| Cyclic(2) (5 copies)
1
> time cl := LMGClasses(G);
#Warning: we will need to find a perm rep of the radical quotient!
#Found perm rep of the radical quotient of degree 31
Time: 0.750
> #cl;
41
> time X := LMGCharacterTable(G);
Time: 4.510
> {* Degree(x): x in X *};
{* 1, 30, 124, 155, 217, 248, 280, 315^^6, 465^^4, 496,
651^^3, 744^^2, 868, 930^^3, 960, 1024, 1240, 1488, 1736^^4,
1984, 3720^^3, 11160^^2 *}
> &+[d^2 : d in $1] eq #G;
true
```
### Finding a Base
If the radical quotient $Q$ of the matrix group $G$ over a finite field has been successfully computed using `RadicalQuotient` or `LMGRadicalQuotient`, then $Q$ and the associated homomorphism $Q \to Q$ can be used to look for a base for $G$ (see [Base and Strong Generating Set](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverGeneralRings/BSGS-base-strong-generator.md#sec-bsgs)). This will typically make further structural computations with $G$ either possible (if they were not possible without a base) or more efficient. Even if a base is already known, the new base computed may be better: it will often have shorter associated basic orbit lengths, for example.
#### `LMGBase(G : parameters): GrpMat -> Tup, SeqEnum, SeqEnum`
```magma
SetBase: BoolElt Default: true
DimLim : RngIntElt Default: 0
Print : RngIntElt Default: 0
```
Use the radical quotient $Q$ of $G$ and associated homomorphism $G \to Q$ to find a base for $G$. return the base `B`, the sequence `BDim` of dimensions of the subspaces (or vectors, assigned dimension $1$) in $B$, and the sequence `BOL` of associated basic orbit lengths. If no base is found then ane empty tuple and sequences are returned.
If the parameter `SetBase` is `true` and a base `B` is found, then the `Base` attribute for $G$ is set to `B`, and so this base will be used for all subsequent calculations.
The parameter `DimLim` is a limit on the dimensions of subspaces that will be considered as possible base points. The default is half od the dimension of $G$. Subspaces of large dimension in a base can result in slower subsequent calculations but, on the other hand, restricting the dimension can result in a base with longer basic orbit lengths, so it can be difficult to find the right balance. If is important to find an optimal base (because it will be used for lengthy subsequent calculations) then it is worthwhile running `LMGBase` several times with different values of `DimLim` to try and get the best possible result.
As an example, we compute a base of a group from the ATLAS database.
#### `Example: Base of a Large Matrix Group (ex-c9a7be)`
```magma
> G := MatrixGroup("6M22",1);
> G:Minimal;
MatrixGroup(66, GF(5^2)) of order 2^8 * 3^3 * 5 * 7 * 11
> B, BDim, BOL := LMGBase(G);
> BDim, BOL;
[ 6, 6, 6, 6, 6, 1 ]
[ 22, 21, 20, 16, 3, 6 ]
> B, BDim, BOL := LMGBase(G : DimLim := 1);
> BDim, BOL;
[ 1, 1, 1, 1 ]
[ 672, 66, 10, 6 ]
```
Note that the default methods for computing a base of this group usually result in much longer basic orbit lengths (but this varies from run to run).
```magma
> G := MatrixGroup("6M22",1);
> BSGS(G);
> BasicOrbitLengths(G);
[ 3696, 6, 60, 2 ]
```
### Unipotent Matrix Groups
The *power-conjugate presentation* is a very efficient way of representing a unipotent group; see Chapter [Finite Soluble Groups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/index-finite-soluble-groups.md#chapgrppc) for more information. In this section we describe a number of functions for finding such a *PC-presentation* for a unipotent matrix group defined over a finite field.
The algorithm used is a straightforward echelonisation-like procedure.
#### `UnipotentMatrixGroup(G): GrpMat -> GrpMatUnip`
Given a matrix group $G$ defined over a finite field, the intrinsic constructs a known unipotent matrix group from $G$. Note that Magma does not at this stage check that $G$ is in fact unipotent.
#### `WordMap(G): GrpMatUnip -> Map`
Given a unipotent matrix group $G$ defined over a finite field, the intrinsic constructs the *word map* for $G$. The word map is a map from $G$ to the group of straight-line programs on $n$ generators, where $n$ is the number of generators of $G$. More information on SLP-groups may be found in Chapter [Groups of Straight-Line Programs](https://docs.magma-maths.org/FinitelyPresentedGroups/GroupsOfStraightLinePrograms/index-groups-of-straight-line-programs.md#chapgrpslp).
#### `Example: Word Map of a Unipotent Group (ex-30af78)`
We construct a unipotent matrix group, and use the word map.
```magma
> G := MatrixGroup<4, GF(5) | [1,1,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1],
> [1,-1,0,0, 0,1,1,0, 0,0,1,0, 0,0,0,1]>;
> G;
MatrixGroup(4, GF(5))
Generators:
[1 1 0 0]
[0 1 0 0]
[0 0 1 0]
[0 0 0 1]
[1 4 0 0]
[0 1 1 0]
[0 0 1 0]
[0 0 0 1]
> IsUnipotent(G);
true
>
> G := UnipotentMatrixGroup(G);
> g := GL(4,5)![1,4,4,0, 0,1,3,0, 0,0,1,0, 0,0,0,1];
> g in G;
true
> phi := WordMap(G);
> phi;
Mapping from: GL(4, GF(5)) to SLPGroup(2) given by a rule [no inverse]
>
> assert g in G;
> wg := phi(g); wg;
function(G)
w6 := G.1^4; w1 := G.1^-4; w2 := G.2 * w1; w7 := w2^3; w8 := w6 *
w7; w3 := G.1^-1; w4 := G.1^w2; w5 := w3 * w4; w9 := w5^2; w10 :=
w8 * w9; return w10;
end function
> Evaluate(wg, G);
[1 4 4 0]
[0 1 3 0]
[0 0 1 0]
[0 0 0 1]
> Evaluate(wg, G) eq g;
true
```
#### `PCPresentation(G): GrpMatUnip -> GrpPC, Map, Map`
Given a unipotent matrix group $G$ defined over a finite field, the intrinsic constructs a PC-presentation for $G$. It returns a finite soluble group $H$ as first return value, a map from $G$ to $H$ as the second value, and a map from $H$ to $G$ as the third.
#### `Order(G): GrpMatUnip -> RngIntElt`
#### `# G: GrpMatUnip -> RngIntElt`
#### `FactoredOrder(G): GrpMatUnip -> [ ]`
Given a unipotent matrix group $G$ defined over a finite field, this intrinsic returns the order of $G$ as an integer or as a factored integer (depending upon the choice of intrinsic). It is faster than the standard matrix group order intrinsic because of the use of the PC-presentation of $G$.
#### `g in G: GrpMatElt, GrpMatUnip -> BoolElt`
Given a matrix $g$ and a unipotent matrix group $G$ defined over a finite field, the intrinsic returns `true` if $g$ is an element of $G$, and `false` otherwise. It is faster than the standard matrix group membership intrinsic because of the use of the PC-presentation of $G$.
#### `Example: Pc-Presentation of a Unipotent Group (ex-f568e8)`
We construct the PC-presentation of some Sylow subgroup and demonstrate the use of the `FactoredOrder` function.
```magma
> G := UnipotentMatrixGroup(ClassicalSylow(GL(9,7), 7));
> H,phi,psi := PCPresentation(G);
> phi;
Mapping from: GrpMatUnip: G to GrpPC: H given by a rule [no inverse]
> psi;
Mapping from: GrpPC: H to GrpMatUnip: G
> phi(G.2);
H.9
> psi(H.3);
[1 0 0 0 0 0 0 0 0]
[0 1 0 0 0 0 0 0 0]
[0 0 1 1 0 0 0 0 0]
[0 0 0 1 0 0 0 0 0]
[0 0 0 0 1 0 0 0 0]
[0 0 0 0 0 1 0 0 0]
[0 0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 0 1 0]
[0 0 0 0 0 0 0 0 1]
> FactoredOrder(G);
[ <7, 36> ]
```
## Matrix Groups over Infinite Fields
- [Overview](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/Overview.md)
- [Construction of Congruence Homomorphisms](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/congruence.md)
- [`CongruenceImage(G : parameters): GrpMat → GrpMat, HomGrp, []`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/congruence.md#function-congruenceimage-grpmat)
- [Testing Finiteness](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/finite-test.md)
- [`IsFinite(G : parameters): GrpMat → BoolElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/finite-test.md#function-isfinite-grpmat)
- [`IsomorphicCopy(G : parameters): GrpMat → BoolElt, GrpMat, HomGrp`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/finite-test.md#function-isomorphiccopy-grpmat)
- [`Order(G : parameters): GrpMat → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/finite-test.md#function-order-grpmat)
- [Deciding Virtual Properties of Linear Groups](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/virtual_tests.md)
- [`IsSolubleByFinite(G : parameters): GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/virtual_tests.md#function-issolublebyfinite-grpmat)
- [`IsPolycyclicByFinite(G : parameters): GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/virtual_tests.md#function-ispolycyclicbyfinite-grpmat)
- [`IsNilpotentByFinite(G : parameters): GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/virtual_tests.md#function-isnilpotentbyfinite-grpmat)
- [`IsAbelianByFinite(G : parameters): GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/virtual_tests.md#function-isabelianbyfinite-grpmat)
- [`IsCentralByFinite(G : parameters): GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/virtual_tests.md#function-iscentralbyfinite-grpmat)
- [Hirsch Number and Prüfer Rank](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/hirsch_rank.md)
- [`HasFiniteRank(G): GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/hirsch_rank.md#function-hasfiniterank-grpmat)
- [`HirschNumber(G): GrpMat → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/hirsch_rank.md#function-hirschnumber-grpmat)
- [`HasFiniteIndex(G, H): GrpMat, GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/hirsch_rank.md#function-hasfiniteindex-grpmat-grpmat)
- [`PrueferRankBound(G): GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/hirsch_rank.md#function-prueferrankbound-grpmat)
- [Other Properties of Linear Groups](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/other-properties.md)
- [`IsCompletelyReducible(G : parameters): GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/other-properties.md#function-iscompletelyreducible-grpmat)
- [`CompletelyReduciblePart(G): GrpMat → GrpMat, GrpMatElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/other-properties.md#function-completelyreduciblepart-grpmat)
- [`IsUnipotent(G): GrpMat → BoolElt, GrpMatElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/other-properties.md#function-isunipotent-grpmat)
- [`IsNilpotent(G): GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/other-properties.md#function-isnilpotent-grpmat)
- [`IsSoluble(G : parameters): GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/other-properties.md#function-issoluble-grpmat)
- [`IsPolycyclic(G : parameters): GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/other-properties.md#function-ispolycyclic-grpmat)
- [`HasFiniteOrder(g : parameters ): GrpMatElt → BoolElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/other-properties.md#function-hasfiniteorder-grpmatelt)
- [Other Functions for Nilpotent Matrix Groups](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/nilpotent_groups.md)
- [`RecogniseAbelian(G): GrpMat → GrpGPC, Map, Map`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/nilpotent_groups.md#function-recogniseabelian-grpmat)
- [`SylowSystem(G : parameters): GrpMat[FldFin] → []`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/nilpotent_groups.md#function-sylowsystem-grpmat-fldfin)
- [`IsIrreducibleFiniteNilpotent(G : parameters): GrpMat → BoolElt, Any`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/nilpotent_groups.md#function-isirreduciblefinitenilpotent-grpmat)
- [`IsPrimitiveFiniteNilpotent(G : parameters): GrpMat → BoolElt, Any`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/nilpotent_groups.md#function-isprimitivefinitenilpotent-grpmat)
- [Examples](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/examples.md)
- [Example: Finite Group over a Rational Function Field](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/examples.md#example-ex-3405c0)
- [Example: Finite Group in Characteristic 5](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/examples.md#example-ex-eadd93)
- [Example: Infinite Group in Characteristic 5](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/examples.md#example-ex-b89ce7)
- [Example: Infinite Integral Matrix Group](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/examples.md#example-ex-83679b)
- [Example: Infinite Group over a Quadratic Field](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/examples.md#example-ex-cd9712)
- [Example: Infinite Group over a Quartic Number Field](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/examples.md#example-ex-d1ef57)
- [Example: Group over an Algebraic Function Field](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/examples.md#example-ex-e6bb73)
- [Example: Finite Group in Characteristic 2](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/examples.md#example-ex-b2fc02)
- [Example: Hirsch Number and Finite Index](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/examples.md#example-ex-65cc00)
- [Example: Completely Reducible Part of a Group](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/examples.md#example-ex-b02d39)
- [Example: Imprimitive Finite Nilpotent Group](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/examples.md#example-ex-1259d9)
- [Example: Recognising an Abelian Matrix Group](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/examples.md#example-ex-a460de)
- [Example: Sylow System of a Nilpotent Group](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/examples.md#example-ex-644306)
- [Example: Infinite Nilpotent Group over a Function Field](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/examples.md#example-ex-8207b7)
- [Bibliography](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/bibliography.md)
### Overview
In this chapter we provide algorithms for computing with a group $G$ given by a finite set $S = \{ g_1, \ldots, g_r \}$ of invertible $n \times n$ matrices over an infinite field $K$. The algorithms are based on special techniques developed for computing in this class of groups ([[DEF11](https://docs.magma-maths.org/references.md#cite-def-survey), [DF08](https://docs.magma-maths.org/references.md#cite-draft), [DF09](https://docs.magma-maths.org/references.md#cite-zero), [DFO09](https://docs.magma-maths.org/references.md#cite-positive), [DFO11](https://docs.magma-maths.org/references.md#cite-tits), [DFO13a](https://docs.magma-maths.org/references.md#cite-rank), [DFO13b](https://docs.magma-maths.org/references.md#cite-recog)]), which rely on properties of finitely generated linear groups.
The group $G$ is defined over the subring $R$ of $K$ generated by the entries of the matrices $g_i, {g_i}^{-1}$ , $1 \leq i \leq r$. If $\rho$ is an ideal of $R$, then it induces a congruence homomorphism from $GL(n, R)$ onto $GL(n, R/\rho)$, which replaces every entry of an element in $S$ by its image in $R/\rho$. Our techniques depend on the construction of a congruence homomorphism with the property that all torsion elements of its kernel $G_{\rho}$ (called a congruence subgroup) are unipotent. The existence of a normal subgroup of finite index in $G$ with such a property was proved by Selberg and Wehrfritz. One advantage of the congruence homomorphism techniques is that they replace the ground domain by a domain that is more convenient for computing. In particular, if the ideal $\rho$ is maximal, then we get a reduction to a finite field $R/\rho$. For more details on the method see [[DF08](https://docs.magma-maths.org/references.md#cite-draft), Section 3].
In this chapter we provide four sets of functions based on the above techniques.
(a) Functions which test finiteness of matrix groups over a wide range of infinite domains. These functions are implementations of algorithms developed in [[DF09](https://docs.magma-maths.org/references.md#cite-zero), [DFO09](https://docs.magma-maths.org/references.md#cite-positive), [DFO13b](https://docs.magma-maths.org/references.md#cite-recog)]. Together with other currently available algorithms for deciding finiteness, they enable testing finiteness of a finitely generated linear group over an arbitrary field (subject to special representation of input data). Additionally, if a group is found to be finite, then we can construct an isomorphic copy over a finite field, and use that for further structural investigation of the group.
(b) Functions for testing various properties of infinite matrix groups. These functions test whether $G$ is soluble-by-finite or soluble, nilpotent-by-finite or nilpotent, abelian-by-finite, or central-by-finite. In effect, they provide access to the first publicly available implementations of algorithms to decide the “Tits alternative” for a linear group. If $G$ is soluble-by-finite we can test whether it is completely reducible. These functions are implementations of algorithms developed in [[DFO11](https://docs.magma-maths.org/references.md#cite-tits)].
(c) Functions to decide whether a soluble-by finite group $G$ defined over $Q$ or a number field has finite rank, to determine its Hirsch number, and to decide if a subgroup of $G$ has finite index. These functions are implementations of algorithms developed in [[DFO13a](https://docs.magma-maths.org/references.md#cite-rank)].
(d) Functions for testing nilpotency and computing with nilpotent matrix groups. These functions are implementation of algorithms developed in [[DF08](https://docs.magma-maths.org/references.md#cite-draft)], which in turn are based on algorithms in [[DF06](https://docs.magma-maths.org/references.md#cite-large)] for computing with nilpotent matrix groups over finite fields. The functions may also be used for investigating the structure of nilpotent matrix groups. In particular, special algorithms have been developed for deciding finiteness of nilpotent matrix groups. Functions are also available to decide irreducibility and primitivity for finite nilpotent matrix groups over number fields and function fields in zero characteristic; these algorithms, developed and implemented by Tobias Rossmann, are described in [[Ros10](https://docs.magma-maths.org/references.md#cite-ros10a), [Ros11](https://docs.magma-maths.org/references.md#cite-ros10b)].
Since $G$ is finitely generated, it is defined over a finitely generated subfield of $K$. Hence, the main fields to be considered are finite degree extensions of $F(x_1, \ldots, x_m)$, where the $x_1, \ldots, x_m$ are algebraically independent indeterminates, $m \geq 0$, and the coefficient field $F$ is an number field or a finite field.
For a recent survey of work in the area of computing with matrix groups over infinite fields, we refer to [[DEF11](https://docs.magma-maths.org/references.md#cite-def-survey)].
Verbose output for these functions can be obtained with `SetVerbose ("Infinite", 1);`
### Construction of Congruence Homomorphisms
In this section, $K$ is a finite degree extension of $F(x_1, \ldots, x_m)$, where $F$ is $Q$, a number field, or a finite field. Also $m \geq 0$ if char $F$ = 0, and $m > 0$ otherwise.
#### `CongruenceImage(G : parameters): GrpMat -> GrpMat, HomGrp, []`
```magma
Virtual : BoolElt Default: false
Prime : RngIntElt Default: 3
Limit : RngIntElt Default: 10
ExtDegree: RngIntElt Default: 1
```
If $G$ is a finitely generated subgroup of ${\operatorname{GL}}(n, K)$, then $G$ has a normal subgroup $N$ whose torsion elements are unipotent; so $N$ is torsion-free if $K$ has characteristic 0.
This function constructs a *congruence homomorphism* from $G$ into ${\operatorname{GL}}(n, {\bf F}_{q})$ for some prime power $q$; its kernel is $N$. If char $K$ is positive, then ${\bf F}_{q}$ has the same characteristic.
For a detailed description of the congruence homomorphisms see [[DFO13b](https://docs.magma-maths.org/references.md#cite-recog), Section 3]. The function returns the congruence image $H$, the congruence homomorphism, and the list of images of generators of $G$.
If the optional parameter `Virtual` is set to `true` then the congruence homomorphism satisfies additional properties [[DFO11](https://docs.magma-maths.org/references.md#cite-tits)]. In particular it can be used to test whether $G$ satisfies the “virtual” properties described in Section [Deciding Virtual Properties of Linear Groups](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/virtual_tests.md#virtual).
The optional parameter `Prime` applies if $K$ has characteristic 0: if `Prime` is positive, then it is a lower bound for the characteristic of the congruence image; if it is 0 then the function returns a congruence image defined over a field of characteristic 0.
The optional parameter `Limit` applies to groups defined over (rational) function fields. If char $K > 0$, then we consider extensions of $F$ to degree `Limit` only; otherwise we examine tuples in the ring of integers mod `Limit`.
The optional parameter `ExtDegree` applies to groups defined over (algebraic) function fields of positive characteristic: we construct a congruence image over an extension of (at least) this degree of coefficient field.
### Testing Finiteness
In this section, $K$ is a finite degree extension of the field $F(x_1, \ldots, x_m)$, where $F$ is $Q$, a number field, or a finite field. Also $m \geq 0$ if char $F = 0$, and $m > 0$ otherwise.
#### `IsFinite(G : parameters): GrpMat -> BoolElt, RngIntElt`
```magma
NumberRandom : RngIntElt Default: 10
Presentation : MonStgElt Default: "CT"
Small : RngIntElt Default: 10^6
OrderLimit : RngIntElt Default: 10^15
Algebra : BoolElt Default: true
Nilpotent : BoolElt Default: false
UseCongruence : BoolElt Default: false
DetermineOrder: BoolElt Default: false
Prime : RngintElt Default: 3
```
Let $G$ be a finitely generated subgroup of ${\operatorname{GL}}(n, K)$. If $G$ is finite then the function returns `true`, otherwise `false`. The function is an implementation of algorithms from [[DF08](https://docs.magma-maths.org/references.md#cite-draft), [DF09](https://docs.magma-maths.org/references.md#cite-zero), [DFO09](https://docs.magma-maths.org/references.md#cite-positive), [DFO13b](https://docs.magma-maths.org/references.md#cite-recog)].
The algorithm first tests whether `NumberRandom` random elements of $G$ have finite order.
If the optional parameter `Algebra` is `true` and $K$ is a function field of characteristic zero (resp. positive characteristic), then we use the “algebra algorithm” of [[DF09](https://docs.magma-maths.org/references.md#cite-zero)] (resp. [[DFO09](https://docs.magma-maths.org/references.md#cite-positive)]) to decide finiteness.
Otherwise, we prove that $G$ is finite by first constructing a congruence homomorphism, then a presentation for the congruence image, and finally evaluates its relations to obtain normal generators for the congruence kernel. If char $K = 0$, then the kernel should be trivial, otherwise the kernel is unipotent.
The optional parameter `Presentation` is used to dictate how the presentation is constructed. If its value is “CT”, then we use the presentation provided by `CompositionTreeVerify`. If its value is “PC” and the image is soluble, then we use a PC-presentation provided by `LMGSolubleRadical`. If its value is “FP” then we use the presentation provided by `FPGroup` or `FPGroupStrong`. If the order of the congruence image is less than the value of the optional argument `Small`, then we use `FPGroup` to construct the presentation; if it is less than the value of the optional argument `OrderLimit`, then we use `FPGroupStrong` to construct the presentation; otherwise we use the presentation provided by `CompositionTreeVerify`.
If $K$ is $Q$ or a number field and `UseCongruence` is `true`, then use congruence homomorphism machinery to decide; otherwise use default algorithm.
If $G$ is known to be nilpotent then by setting the optional parameter `Nilpotent` to `true`, the function will call a special procedure for testing finiteness of nilpotent groups (see [[DF08](https://docs.magma-maths.org/references.md#cite-draft), Section 4.3]).
If the optional parameter `DetermineOrder` is set to `true`, and $G$ is finite, then the function returns the order of $G$. This may sometimes be more expensive than deciding finiteness.
The optional parameter `Prime` applies if $K$ has characteristic 0: if `Prime` is positive, then it is a lower bound for the characteristic of the congruence image; if it is 0 then the function constructs a congruence image defined over a field of characteristic 0.
#### `IsomorphicCopy(G : parameters): GrpMat -> BoolElt, GrpMat, HomGrp`
```magma
Presentation : MonStgElt Default: "CT"
Small : RngIntElt Default: 10^6
OrderLimit : RngIntElt Default: 10^15
Verify : BoolElt Default: false
Algebra : BoolElt Default: false
StartDegree : RngIntElt Default: 1
EndDegree : RngIntElt Default: 5
CompletelyReducible: BoolElt Default: false
```
The input is a finite subgroup $G$ of ${\operatorname{GL}}(n, K)$. If the function succeeds, then it returns `true` and an isomorphic copy of $G$ in ${\operatorname{GL}}(n,{\bf F}_{q})$ where $q$ is a prime power; otherwise it returns `false`. A description of the method used is in [[DFO13b](https://docs.magma-maths.org/references.md#cite-recog), Section 4.3]. If char $K > 0$, then ${\bf F}_{q}$ has the same characteristic. Note that the function always succeeds if $K$ has zero characteristic.
If the optional parameter `Algebra` is `true` and $K$ is a function field of characteristic zero (resp. positive characteristic), then we use the “algebra algorithm” of [[DF09](https://docs.magma-maths.org/references.md#cite-zero)] (resp. [[DFO09](https://docs.magma-maths.org/references.md#cite-positive)]) to construct an isomorphic copy.
Otherwise we prove that a congruence homomorphism is an isomorphism by constructing a presentation for the congruence image and evaluating its relations to obtain normal generators for the congruence kernel.
The optional parameter `Presentation` is used to dictate how the presentation is constructed. If its value is “CT”, then we use the presentation provided by `CompositionTreeVerify`. If its value is “PC” and the image is soluble, then we use a PC-presentation provided by `LMGSolubleRadical`. If its value is “FP” then we use the presentation provided by `FPGroup` or `FPGroupStrong`. If the order of the congruence image is less than the value of the optional argument `Small`, then we use `FPGroup` to construct the presentation; if it is less than the value of the optional argument `OrderLimit`, then we use `FPGroupStrong` to construct the presentation; otherwise we use the presentation provided by `CompositionTreeVerify`.
If the optional parameter `Verify` is set to `true` then we first check whether $G$ is finite.
If the characteristic of the coefficient field $F$ is positive, then we investigate extensions of $F$ in the range `StartDegree` $\ldots$ `EndDegree`.
If the optional parameter `CompletelyReducible` is set to `true` then we use a more efficient algorithm to construct the isomorphic copy.
#### `Order(G : parameters): GrpMat -> RngIntElt`
```magma
Verify : BoolElt Default: false
UseCongruence: BoolElt Default: false
```
Given a finite subgroup $G$ of ${\operatorname{GL}}(n,K)$, the function returns the order of $G$ by applying `IsomorphicCopy` to $G$.
If the optional parameter `Verify` is set to `true`, then we first check that $G$ is finite.
If $K$ is $Q$ or a number field and `UseCongruence` is `true`, then use congruence homomorphism machinery to decide; otherwise use default algorithm.
### Deciding Virtual Properties of Linear Groups
In this section, $K$ is a finite degree extension of $F(x_1, \ldots, x_m)$, where $F$ is $Q$, a number field, or a finite field. Also $m \geq 0$ if char $F = 0$, and $m > 0$ otherwise.
We describe algorithms to decide various “virtual” properties of a finitely generated linear group over an infinite field. Details of the algorithms can be found in [[DFO11](https://docs.magma-maths.org/references.md#cite-tits)].
#### `IsSolubleByFinite(G : parameters): GrpMat -> BoolElt`
```magma
Presentation : MonStgElt Default: "CT"
OrderLimit : RngIntElt Default: 10^15
Small : RngIntElt Default: 10^6
NeedChangeOfBasis: BoolElt Default: false
```
This function takes as input a finitely generated matrix group $G$ over $K$, and tests whether $G$ is soluble-by-finite. If so, it returns `true`, otherwise `false`. Note that currently the function is valid only for $p>n$ if $K$ has characteristic $p>0$.
The algorithm first constructs a congruence homomorphism, then a presentation for the congruence image, and finally evaluates its relations to obtain normal generators for the congruence kernel. For further details, see [[DFO11](https://docs.magma-maths.org/references.md#cite-tits), Section 3.2].
The optional parameter `Presentation` is used to dictate how the presentation is constructed. If its value is “CT”, then we use the presentation provided by `CompositionTreeVerify`. If its value is “PC” and the image is soluble, then we use a PC-presentation provided by `LMGSolubleRadical`. If its value is “FP” then we use the presentation provided by `FPGroup` or `FPGroupStrong`. If the order of the congruence image is less than the value of the optional argument `Small`, then we use `FPGroup` to construct the presentation; if it is less than the value of the optional argument `OrderLimit`, then we use `FPGroupStrong` to construct the presentation; otherwise we use the presentation provided by `CompositionTreeVerify`. If `NeedChangeOfBasis` is `true`, then a change-of-basis matrix is computed and recorded which explictly exhibits $G$ as a group of block lower-triangular matrices.
#### `IsPolycyclicByFinite(G : parameters): GrpMat -> BoolElt`
```magma
Presentation: MonStgElt Default: "CT"
OrderLimit : RngIntElt Default: 10^15
Small : RngIntElt Default: 10^6
```
This function takes as input a finitely generated matrix group $G$ over $Z$, and tests whether $G$ is polycyclic-by-finite. If so, it returns `true`, otherwise `false`. See [[DFO11](https://docs.magma-maths.org/references.md#cite-tits), Section 3.2] for details.
The optional parameter `Presentation` is used to dictate how the presentation is constructed. If its value is “CT”, then we use the presentation provided by `CompositionTreeVerify`. If its value is “PC” and the image is soluble, then we use a PC-presentation provided by `LMGSolubleRadical`. If its value is “FP” then we use the presentation provided by `FPGroup` or `FPGroupStrong`. If the order of the congruence image is less than the value of the optional argument `Small`, then we use `FPGroup` to construct the presentation; if it is less than the value of the optional argument `OrderLimit`, then we use `FPGroupStrong` to construct the presentation; otherwise we use the presentation provided by `CompositionTreeVerify`.
#### `IsNilpotentByFinite(G : parameters): GrpMat -> BoolElt`
```magma
Presentation: MonStgElt Default: "CT"
OrderLimit : RngIntElt Default: 10^15
Small : RngIntElt Default: 10^6
```
This function takes as input a finitely generated matrix group $G$ over $K$, and tests whether $G$ is nilpotent-by-finite. If so, it returns `true`, otherwise `false`. Here $K$ must currently be $Q$, a number field, or an (algebraic) function field with a single indeterminate.
The algorithm first constructs a congruence homomorphism, then a presentation for the congruence image, and finally evaluates its relations to obtain normal generators for the congruence kernel. Further details of the algorithm can be found in [[DFO11](https://docs.magma-maths.org/references.md#cite-tits), Section 5.2].
The optional parameter `Presentation` is used to dictate how the presentation is constructed. If its value is “CT”, then we use the presentation provided by `CompositionTreeVerify`. If its value is “PC” and the image is soluble, then we use a PC-presentation provided by `LMGSolubleRadical`. If its value is “FP” then we use the presentation provided by `FPGroup` or `FPGroupStrong`. If the order of the congruence image is less than the value of the optional argument `Small`, then we use `FPGroup` to construct the presentation; if it is less than the value of the optional argument `OrderLimit`, then we use `FPGroupStrong` to construct the presentation; otherwise we use the presentation provided by `CompositionTreeVerify`.
#### `IsAbelianByFinite(G : parameters): GrpMat -> BoolElt`
```magma
Presentation: MonStgElt Default: "CT"
OrderLimit : RngIntElt Default: 10^15
Small : RngIntElt Default: 10^6
```
This function takes as input a finitely generated matrix group $G$ over $K$, and tests whether $G$ is abelian-by-finite. If so, it returns `true`, otherwise `false`. As before, $K$ must currently be $Q$, a number field, or an (algebraic) function field with a single indeterminate.
The algorithm first constructs a congruence homomorphism, then a presentation for the congruence image, and finally evaluates its relations to obtain normal generators for the congruence kernel. Further details of the algorithm can be found in [[DFO11](https://docs.magma-maths.org/references.md#cite-tits), Section 5.2].
The optional parameter `Presentation` is used to dictate how the presentation is constructed. If its value is “CT”, then we use the presentation provided by `CompositionTreeVerify`. If its value is “PC” and the image is soluble, then we use a PC-presentation provided by `LMGSolubleRadical`. If its value is “FP” then we use the presentation provided by `FPGroup` or `FPGroupStrong`. If the order of the congruence image is less than the value of the optional argument `Small`, then we use `FPGroup` to construct the presentation; if it is less than the value of the optional argument `OrderLimit`, then we use `FPGroupStrong` to construct the presentation; otherwise we use the presentation provided by `CompositionTreeVerify`.
#### `IsCentralByFinite(G : parameters): GrpMat -> BoolElt`
```magma
Presentation : MonStgElt Default: "CT"
OrderLimit : RngIntElt Default: 10^15
Small : RngIntElt Default: 10^6
CompletelyReducible: BoolElt Default: false
```
This function takes as input a finitely generated matrix group $G$ over a field $K$, and tests whether $G$ is central-by-finite. If so, it returns `true`, otherwise `false`. Here $K$ is (a finite degree extension of) $F(x_1, \ldots, x_m)$, where $F$ is $Q$ or a number field.
The algorithm first constructs a congruence homomorphism, then a presentation for the congruence image, and finally evaluates its relations to obtain normal generators for the congruence kernel. Further details of the algorithm can be found in [[DFO11](https://docs.magma-maths.org/references.md#cite-tits), Section 5.3].
The optional parameter `Presentation` is used to dictate how the presentation is constructed. If its value is “CT”, then we use the presentation provided by `CompositionTreeVerify`. If its value is “PC” and the image is soluble, then we use a PC-presentation provided by `LMGSolubleRadical`. If its value is “FP” then we use the presentation provided by `FPGroup` or `FPGroupStrong`. If the order of the congruence image is less than the value of the optional argument `Small`, then we use `FPGroup` to construct the presentation; if it is less than the value of the optional argument `OrderLimit`, then we use `FPGroupStrong` to construct the presentation; otherwise we use the presentation provided by `CompositionTreeVerify`.
If the optional parameter `CompletelyReducible` is set to `true` then we use a more efficient algorithm to test whether $G$ is central-by-finite.
### Hirsch Number and Prüfer Rank
#### `HasFiniteRank(G): GrpMat -> BoolElt`
This function takes as input a finitely generated matrix group $G$ defined over $Q$ or a number field, and determines if it has finite Hirsch number and Prüfer rank. If so, it returns `true`, else `false`.
#### `HirschNumber(G): GrpMat -> RngIntElt`
This function takes as input a finitely generated finite rank matrix group $G$ defined over $Q$ or a number field, and returns its Hirsch number.
#### `HasFiniteIndex(G, H): GrpMat, GrpMat -> BoolElt`
If the subgroup $H$ has finite index in the soluble-by-finite matrix group $G$ defined over $Q$ or a number field, then this function returns `true`, else it returns `false`. It decides this by checking whether $G$ and $H$ have identical Hirsch numbers.
#### `PrueferRankBound(G): GrpMat -> BoolElt`
This function takes as input a finitely generated finite rank matrix group $G$ defined over $Q$ or a number field, and returns an upper bound to its Prüfer rank.
### Other Properties of Linear Groups
In this section, $K$ is a finite degree extension of $F(x_1, \ldots, x_m)$, where $F$ is $Q$, a number field, or a finite field, and $m\geq 0$.
#### `IsCompletelyReducible(G : parameters): GrpMat -> BoolElt`
```magma
SolubleByFinite : BoolElt Default: false
NilpotentByFinite: BoolElt Default: false
AbelianByFinite : BoolElt Default: false
Nilpotent : BoolElt Default: false
Presentation : MonStgElt Default: "CT"
OrderLimit : RngIntElt Default: 10^15
Small : RngIntElt Default: 10^6
```
This function takes as input a finitely generated matrix group $G$ over $K$, and tests whether $G$ is completely reducible. If so, it returns `true`, otherwise `false`.
The algorithm used is described in [[DFO11](https://docs.magma-maths.org/references.md#cite-tits), Section 4]. It applies only if $G$ is soluble-by-finite, nilpotent-by-finite, or abelian-by-finite. Hence one (and only one) of the four optional arguments `SolubleByFinite, NilpotentByFinite, AbelianByFinite, Nilpotent` must be true. In particular, if `Nilpotent` is set to be true, then a more efficient algorithm (from [[DF08](https://docs.magma-maths.org/references.md#cite-draft)]) is used.
In positive characteristic $p$, if $p$ divides the order of the congruence image of $G$ then currently the algorithm cannot decide complete reducibility of $G$.
The optional parameter `Presentation` is used to dictate how the presentation is constructed. If its value is “CT”, then we use the presentation provided by `CompositionTreeVerify`. If its value is “PC” and the image is soluble, then we use a PC-presentation provided by `LMGSolubleRadical`. If its value is “FP” then we use the presentation provided by `FPGroup` or `FPGroupStrong`. If the order of the congruence image is less than the value of the optional argument `Small`, then we use `FPGroup` to construct the presentation; if it is less than the value of the optional argument `OrderLimit`, then we use `FPGroupStrong` to construct the presentation; otherwise we use the presentation provided by `CompositionTreeVerify`.
#### `CompletelyReduciblePart(G): GrpMat -> GrpMat, GrpMatElt`
Let $H$ be a matrix group in block lower triangular form, and let $\mu$ be the projection of $H$ onto its diagonal blocks. If all diagonal blocks of $H$ are completely reducible, then $\ker \mu$ is the unipotent radical of $H$ and $\mu(H)$ is a ‘completely reducible part’ of $H$.
$G$ is a soluble-by-finite group defined over $Q$ or over a number field. The function returns a completely reducible part of $G$ and a change-of-basis matrix to exhibit this.
In positive characteristic $p$, if $p$ divides the order of the congruence image of $G$ then currently the algorithm cannot construct a completely reducible part.
#### `IsUnipotent(G): GrpMat -> BoolElt, GrpMatElt`
This function takes as input a finitely generated matrix group $G$ defined over an exact field $F$, and tests whether $G$ is unipotent, i.e., whether it is conjugate in ${\operatorname{GL}}(n, F)$ to a group of upper unitriangular matrices. If $G$ is unipotent then the function returns `true` and a change-of-basis matrix $c \in {\operatorname{GL}}(n, F)$ such that $G^c$ is upper unitriangular, otherwise `false`. See [[DF06](https://docs.magma-maths.org/references.md#cite-large), Section 2.1] for details of the algorithm.
#### `IsNilpotent(G): GrpMat -> BoolElt`
Let $G$ be a finitely generated subgroup of ${\operatorname{GL}}(n, K)$. This function returns `true` if $G$ is nilpotent; otherwise it returns `false`. If $K$ is finite then the function is an implementation of the algorithm of [[DF06](https://docs.magma-maths.org/references.md#cite-large)]. If $K$ is infinite then the function is similar to the algorithm in [[DF08](https://docs.magma-maths.org/references.md#cite-draft)], and is based on the construction of a homomorphic image $H$ of $G$ via `CongruenceImage`.
#### `IsSoluble(G : parameters): GrpMat -> BoolElt`
```magma
Presentation : MonStgElt Default: "CT"
OrderLimit : RngIntElt Default: 10^15
Small : RngIntElt Default: 10^6
UseCongruence: BoolElt Default: false
```
Let $G$ be a finitely generated subgroup of ${\operatorname{GL}}(n, K)$. This function returns `true` if $G$ is soluble; otherwise it returns `false`. If $K$ is infinite and has characteristic $p>0$, then the algorithm is applicable only for $p > n$. For details see [[DFO11](https://docs.magma-maths.org/references.md#cite-tits), Section 3.2].
If $K$ is $Q$ or a number field and `UseCongruence` is `true`, then use congruence homomorphism machinery to decide; otherwise use default algorithm.
The other optional arguments are those described above for `IsSolubleByFinite`.
#### `IsPolycyclic(G : parameters): GrpMat -> BoolElt`
```magma
Presentation: MonStgElt Default: "CT"
OrderLimit : RngIntElt Default: 10^15
Small : RngIntElt Default: 10^6
```
This function takes as input a finite matrix group $G$ over $Z$, and tests whether $G$ is polycyclic. If so, it returns `true`, otherwise `false`.
The optional arguments are those described above for `IsSolubleByFinite`.
#### `HasFiniteOrder(g : parameters): GrpMatElt -> BoolElt, RngIntElt`
```magma
UseCongruence: BoolElt Default: false
```
Let $g$ be an invertible matrix defined over $Z$, $Q$, a number field, a function field, or an algebraic function field.
If $g$ has finite order, then return `true` and, if known, a multiplicative upper bound for the order of $g$; else return `false`.
If $g$ is defined over $Z$, $Q$, or a number field and `UseCongruence` is `true`, then use congruence homomorphism machinery to decide; otherwise use default algorithm.
### Other Functions for Nilpotent Matrix Groups
#### `RecogniseAbelian(G): GrpMat -> GrpGPC, Map, Map`
Given a completely reducible abelian matrix group $G$ defined over $Q$ or a number field, return an isomorphic polycyclic copy $P$, a map from $G$ to $P$, and a map from $P$ to $G$. It uses an algorithm of Biasse and Fieker [[BF12](https://docs.magma-maths.org/references.md#cite-fieker)] to work with irreducible abelian groups defined over number fields.
#### `SylowSystem(G : parameters): GrpMat[FldFin] -> []`
```magma
Verify: BoolElt Default: false
```
Given a nilpotent matrix group $G$ over a finite field, this function constructs one Sylow $p$-subgroup for each prime $p$ dividing $|G|$ using the algorithm of [[DF06](https://docs.magma-maths.org/references.md#cite-large)]. If the optional parameter `Verify` is set to `true`, then we first verify that $G$ is nilpotent.
The next two functions were developed and implemented by Tobias Rossmann.
#### `IsIrreducibleFiniteNilpotent(G : parameters): GrpMat -> BoolElt, Any`
```magma
DecideOnly: BoolElt Default: false
Verify : BoolElt Default: false
```
Let $G$ be a finite nilpotent matrix group over $K$, where $K$ is a number field or a rational function field over a number field. The function returns `true` if $G$ is irreducible or `false` and a proper submodule of `GModule(G)`. The construction of a submodule can be suppressed by setting `DecideOnly` to `true`. If the optional parameter `Verify` is set to `true`, then the function checks if $G$ is nilpotent and finite. The algorithm used for irreducibility testing is described in [Ros10a].
#### `IsPrimitiveFiniteNilpotent(G : parameters): GrpMat -> BoolElt, Any`
```magma
DecideOnly: BoolElt Default: false
Verify : BoolElt Default: false
```
Let $G$ be an irreducible finite nilpotent matrix group over $K$, where $K$ is a number field or a rational function field over a number field. The function returns `true` if $G$ is primitive, or `false` and a system of imprimitivity for $G$ given as a sequence of subspaces of `RSpace(G)`. The construction of a system of imprimitivity can be suppressed by setting `DecideOnly` to `true`. If the optional parameter `Verify` is set to `true`, then the function checks if $G$ is nilpotent and finite. The algorithm used for primitivity testing is described in [Ros10b].
### Examples
#### `Example: Finite Group over a Rational Function Field (ex-3405c0)`
```magma
> Q := Rationals ();
> F:= RationalFunctionField (Q);
> M:= MatrixAlgebra (F, 3);
> a:= M![-1, 2*t^2, -2*t^4 - 2*t^3 - 2*t^2, 0, 1, 0, 0, 0, 1];
> b:= M![1, 0, 0, 1/t^2, -1, (2*t^3 - 1)/(t - 1), 0, 0, 1];
> c:= M![t, -t^3 + t^2, t^5 - t^2 - t, t^2, -t^4, (t^8 - t^5 + 1)/
> (t^2 - t), (t - 1)/t, -t^2 + t, t^4 - t];
> G:= sub;
> IsFinite(G);
true
> flag, H := IsomorphicCopy(G);
> H;
MatrixGroup(3, GF(3))
Generators:
[2 2 1]
[0 1 0]
[0 0 1]
[1 0 0]
[1 2 0]
[0 0 1]
[2 2 2]
[1 2 0]
[2 1 2]
> #H;
48
```
#### `Example: Finite Group in Characteristic 5 (ex-eadd93)`
```magma
> F:= RationalFunctionField (GF(5));
> M:= MatrixAlgebra (F, 6);
> a:= M![2, 2*t^2, 4, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0,
> 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1];
> b:= M![(4*t + 4)/t, 4*t, (t + 1)/t, 0, t, t^2 + t, 0, 4, 0, 0, 0,
> 1/t, 4/t, t^2 + 4*t, 1/t, 0, 0, 0, 0, 4*t, 0, 0, 0, 0, 0, 0, 4, 4,
> 0, 0, 0, 0, 0, 4, 0, 0];
> G:= sub;
> IsFinite(G);
true
> flag, H := IsomorphicCopy (G);
> flag;
true
> H;
MatrixGroup(6, GF(5)) of order 2^7 * 3 * 5^4 * 31
Generators:
[2 2 4 1 0 0]
[0 2 0 0 0 0]
[0 0 1 1 0 0]
[0 0 0 1 0 0]
[0 0 0 0 1 1]
[0 0 0 0 0 1]
[3 4 2 0 1 2]
[0 4 0 0 0 1]
[4 0 1 0 0 0]
[0 4 0 0 0 0]
[0 0 4 4 0 0]
[0 0 0 4 0 0]
> #H;
7440000
```
#### `Example: Infinite Group in Characteristic 5 (ex-b89ce7)`
```magma
> L := RationalFunctionField (GF (5^2));
> G := GL (2, L);
> a := G![t,1,0,-1];
> b:= G![t/(t + 1), 1, 0, 1/t];
> H := sub ;
> f :=IsFinite(H);
> f;
false
> IsSolubleByFinite (H);
true
> IsCompletelyReducible (H);
false
```
#### `Example: Infinite Integral Matrix Group (ex-83679b)`
```magma
> G := MatrixGroup<3, IntegerRing() |
> [ 5608, 711, -711, 6048, 766, -765, 1071, 135, -134 ],
> [ 1, -2415, 5475, 0, 4471, -10140, 0, 780, -1769 ],
> [ 5743, -5742, 639, -576, 577, -72, -711, 711, -80 ],
> [ 526168, -618507, 729315, 621984, -731138, 862125,
> 274455, -322620, 380419 ] ,
> [ 648226, -4621455, 9226791, 660687, -4710305, 9404184,
> 85626, -610473, 1218820 ],
> [ 32581, -39465, 46350, 53100, -64319, 75540, 24210,
> -29325, 34441 ]>;
> IsFinite (G);
false
> IsSolubleByFinite (G);
false
> IsNilpotentByFinite (G);
false
> time IsCentralByFinite (G);
false
> IsAbelianByFinite (G);
false
```
#### `Example: Infinite Group over a Quadratic Field (ex-cd9712)`
```magma
> Q := QuadraticField(5);
> O := sub< MaximalOrder(Q) | 7 >;
> G := GL(2, Q);
> x := G![1,1+w,0,w];
> y := G![-1/2, 2, 2 + w, 5 + w^2];
> H:=sub;
> IsFinite (H);
false
> IsSolubleByFinite (H);
false
```
#### `Example: Infinite Group over a Quartic Number Field (ex-d1ef57)`
```magma
> R := PolynomialRing(Integers());
> K := NumberField(x^4-420*x^2+40000);
> G := GL (2, K);
> a := G![y,1,0,-1];
> b:= G![y/(y + 1), 1, 0, 1/y];
> H := sub ;
> time IsFinite(H);
false
```
#### `Example: Group over an Algebraic Function Field (ex-e6bb73)`
```magma
> /* example over algebraic extension of a function field */
>
> R := FunctionField (Rationals ());
> v := u; w := -2 * v;
> Px := PolynomialRing (R);
> Py := PolynomialRing (R);
> f := Y^2- 3 * u * X * Y^2 + v * X^3;
> facs := Factorisation (f);
> F:=ext ;
> F;
Algebraic function field defined over Univariate rational function
field over Rational Field by Y - 1/2/u
>
> n := 3;
> G:= GL(n,F);
> Z := 4 * X * Y;
> MA:= MatrixAlgebra(F,n);
> h1:= Id(MA);
> h1[n][n]:= (X^2+Y+Z+1);
> h1[1][n]:= X+1;
> h1[1][n]:= X+1;
> h1[1][1]:=(Z^5-X^2*Z+Z*X*Y);
> h1[2][1]:=1-X*Y*Z;
> h1[2][n]:= X^20+X*Y^15+Y^10+Z^4*Y*X^5+1;
> h2:= Id(MA);
> h2[n][n]:= (X^7+Z^6+1);
> h2[1][n]:= X^2+X+1;
> h2[1][1]:=(Y^3+X^2+X+1);
> h2[1][1]:=(Y^3+X^2+X+1);
> h2[2][1]:=1-X^2;
> h2[2][n]:= X^50+Y^35+X^20+X^13+Y^2+1;
> G := sub< GL(n, F) | h1, h2>;
> G;
MatrixGroup(3, F)
Generators:
[1/u^10 0 (u + 1/2)/u]
[(u^4 - 1/4)/u^4 1 (u^20 + 1/1024*u^10 + 1/64*u^6 + 1/65536*u^4 +
1/1048576)/u^20]
[0 0 (u^2 + 1/2*u + 5/4)/u^2]
[(u^3 + 1/2*u^2 + 1/4*u + 1/8)/u^3 0 (u^2 + 1/2*u + 1/4)/u^2]
[(u^2 - 1/4)/u^2 1 (u^50 + 1/4*u^48 + 1/8192*u^37 + 1/1048576*u^30 +
1/34359738368*u^15 + 1/1125899906842624)/u^50]
[0 0 (u^12 + 1/128*u^5 + 1)/u^12]
> time IsFinite(G);
false
Time: 0.010
> time IsSolubleByFinite (G);
true
```
#### `Example: Finite Group in Characteristic 2 (ex-b2fc02)`
```magma
> F := GF(2);
> P := PolynomialRing (F);
> P := PolynomialRing (F);
> F := ext < F | t^2+t+1>;
> G := GL (2, FunctionField (F));
> a := G![1,1/t, 0, 1];
> b := [1,1/(t + 1), 0, 1];
> c := [1,1/(t^2 + t + 1), 0, 1];
> d := [1,1/(t^2 + t), 0, 1];
> G := sub < G | a,b,c,d>;
> time IsFinite (G);
true
> f, I, tau := IsomorphicCopy (G);
> f;
true
```
#### `Example: Hirsch Number and Finite Index (ex-65cc00)`
```magma
> G := MatrixGroup<10, K | [
> Matrix(SparseMatrix(K, 10, 10, [
> <1, 3, -1>, <2, 1, 1>, <2, 2, 1>, <2, 3, 1>, <2, 4, 1>, <2, 5, 1>,
> <3, 4, -1>, <4, 5, -1>, <5, 2, -1>, <6, 8, -1>, <7, 6, 1>,
> <7, 7, 1>, <7, 8, 1>,
> <7, 9, 1>, <7, 10, 1>, <8, 9, -1>, <9, 10, -1>, <10, 7, -1>])),
> Matrix(SparseMatrix(K, 10, 10, [
> <1, 2, 1>, <2, 3, 1>, <3, 1, -1>, <3, 2, -1>, <3, 3, -1>, <3, 4, -1>,
> <3, 5, -1>, <4, 4, 1>, <5, 1, 1>, <6, 7, 1>, <7, 8, 1>, <8, 6, -1>,
> <8, 7, -1>, <8,8, -1>, <8, 9, -1>, <8, 10, -1>, <9, 9, 1>, <10, 6, 1>])),
> ScalarMatrix(K, 10, -1),
> Matrix(SparseMatrix(K, 10, 10, [
> <1, 6, 1>, <2, 7, 1>, <3, 8, 1>, <4, 9, 1>, <5, 10, 1>, <6, 1, w + 3>,
> <7, 2, w + 3>, <8, 3, w + 3>, <9, 4, w + 3>, <10, 5, w + 3>])),
> Matrix(SparseMatrix(K, 10, 10, [
> <1, 6, 1>, <2, 7, 1>, <3, 8, 1>, <4, 9, 1>, <5, 10, 1>,
> <6, 1, 1/5*(5*w - 7)>, <7, 2, 1/5*(5*w - 7)>, <8, 3, 1/5*(5*w - 7)>,
> <9, 4, 1/5*(5*w - 7)>, <10, 5, 1/5*(5*w - 7)>]))
> ]> where w := K.1 where K := ext where K is
> RationalField();
>
> IsIrreducible (GModule (G));
true
> IsSolubleByFinite (G);
true
>
> flag := HasFiniteRank (G);
> "G has finite rank?", flag;
G has finite rank? true
>
> h := HirschNumber(G);
> "Hirsch number of G is ", h;
Hirsch number of G is 3
>
> H := sub;
> HasFiniteIndex (G, H);
true
```
#### `Example: Completely Reducible Part of a Group (ex-b02d39)`
```magma
> G := MatrixGroup<8, RationalField() |
> Matrix(RationalField(), 8, 8, [ -402, -128, 32, 24, -452, 798, -293,
> 349, 3, 37, 20, -9, 5, -11, 29, 7, -67, 56, 5, -15, -105, 133, 21,
> 65, -114, 660, 80, -164, -325, 208, 528, 199, -2, 220, 0, -55, -90,
> 4, 199, 18,-213, 236, 16, -63, -359, 423, 121, 209, -36, 260, 0,
> -65, -144, 72, 221, 57, 3, -228, 0, 57, 94, -6, -206, -20 ]),
> Matrix(RationalField(), 8, 8, [ -446, 1144, -64, -288, -1114, 910,
> 833, 407, -9, 37, -4, -9, -31, 19, 29, 7, -125, 155, -7, -39, -223,
> 252, 77, 113, -510, 428, -16, -106, -779, 1024, 104, 457, -108, 28,
> 0, -7, -134, 216, -35, 96, -407, 608, -32, -153, -781, 823, 347, 367,
> -190, 92, 0, -23, -254, 380, -23, 171, 159, 12, 0, -3, 176, -318,
> 98, -140 ]) >;
>
> IsSolubleByFinite (G: NeedChangeOfBasis := true);
true
> IsCompletelyReducible (G);
false
> I, CB := CompletelyReduciblePart (G);
> "Completely reducible part ", I;
Completely reducible part
MatrixGroup(8, Rational Field)
Generators:
[ 24 -600 266 -535 -69 0 0 0]
[ 63/2 -128 345/4 -103 -171/4 0 0 0]
[ -2 220 -90 199 18 0 0 0]
[ -36 260 -144 221 57 0 0 0]
[ 3 -228 94 -206 -20 0 0 0]
[ 0 0 0 0 0 1 0 0]
[ 0 0 0 0 0 0 1 0]
[ 0 0 0 0 0 0 0 1]
[ 368 -72 448 139 -327 0 0 0]
[ 237/2 -70 655/4 3 -429/4 0 0 0]
[ -108 28 -134 -35 96 0 0 0]
[ -190 92 -254 -23 171 0 0 0]
[ 159 12 176 98 -140 0 0 0]
[ 0 0 0 0 0 1 0 0]
[ 0 0 0 0 0 0 1 0]
[ 0 0 0 0 0 0 0 1]
> "Change-of-basis matrix is ", CB;
Change-of-basis matrix is
[ 1 0 0 0 0 -2 0 0]
[ 0 1 0 -1/4 0 0 0 0]
[ 0 0 0 0 1 0 0 0]
[ 0 0 0 0 0 0 1 0]
[ 0 0 0 0 0 0 0 1]
[ 0 0 1 0 0 -1/4 0 0]
[ 0 0 0 1 0 0 0 0]
[ 0 0 0 0 0 1 0 0]
>
Total time: 0.790 seconds, Total memory usage: 32.09MB
```
#### `Example: Imprimitive Finite Nilpotent Group (ex-1259d9)`
```magma
> // irreducible but (evidently) imprimitive
> K := QuadraticField (2);
> G := MatrixGroup< 8, K |
> [1/2*w,1/2*w,0,0,0,0,0,0,-1/2*w,1/2*w,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
> 0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,
> 0,0,0,1],
> [1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,
> 0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1],
> [0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,
> 0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0] >;
> G;
MatrixGroup(8, K)
Generators:
[ 1/2*w 1/2*w 0 0 0 0 0 0]
[-1/2*w 1/2*w 0 0 0 0 0 0]
[ 0 0 1 0 0 0 0 0]
[ 0 0 0 1 0 0 0 0]
[ 0 0 0 0 1 0 0 0]
[ 0 0 0 0 0 1 0 0]
[ 0 0 0 0 0 0 1 0]
[ 0 0 0 0 0 0 0 1]
[ 1 0 0 0 0 0 0 0]
[ 0 -1 0 0 0 0 0 0]
[ 0 0 1 0 0 0 0 0]
[ 0 0 0 1 0 0 0 0]
[ 0 0 0 0 1 0 0 0]
[ 0 0 0 0 0 1 0 0]
[ 0 0 0 0 0 0 1 0]
[ 0 0 0 0 0 0 0 1]
[0 0 1 0 0 0 0 0]
[0 0 0 1 0 0 0 0]
[0 0 0 0 1 0 0 0]
[0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 1 0]
[0 0 0 0 0 0 0 1]
[1 0 0 0 0 0 0 0]
[0 1 0 0 0 0 0 0]
> IsIrreducibleFiniteNilpotent(G);
true
> r, B := IsPrimitiveFiniteNilpotent(G);
> r;
false
> #B;
2
```
#### `Example: Recognising an Abelian Matrix Group (ex-a460de)`
```magma
> G := MatrixGroup<8, RationalField() |
> Matrix(RationalField(),8,8,[2008, -20376, 10986, -17499, -2961, 0, 0, 0,
> 2205/2, -4964, 13545/4, -3990, -5355/4, 0, 0, 0, -546, 7212, -3698, 6267,
> 882, 0, 0, 0, -1512, 9348, -5724, 7765, 1953, 0, 0, 0, 651, -7812, 4074,
> -6762, -1016, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
> 0, 0, 0, 0, 0, 0, 0, 1 ]),
> Matrix(RationalField(), 8, 8, [ -6371, -304884, 123147, -274455, -2268, 0,
> 0,0,-6741, -91988, 31500, -341397/4, 3591, 0, 0, 0, 1764, 103896, -42443,
> 93312, 1134, 0, 0, 0, 8442, 157356, -57510, 144370, -3402, 0, 0, 0, -378,
> -112644, 47817, -100359, -2591, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
> 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 ]),
> Matrix(RationalField(), 8, 8, [ 68095, -10044, 95553, 20763, -58968, 0, 0,
> 0,49203/2,622, 64575/2, 45423/4, -42903/2, 0, 0, 0, -22176, 1080, -29969,
> -8748, 19278, 0, 0, 0, -39060, 108, -51840, -17036, 34020, 0, 0, 0, 24192,
> -9828, 37233, 1701, -20735, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
> 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 ]),
> Matrix(RationalField(), 8, 8, [ -8810, -109512, 45447, -103143, 11133, 0,
> 0, 0, -5685/2, -35609, 14820, -134115/4, 14445/4, 0, 0, 0, 2748, 33924,
> -14042, 31959, -3456, 0, 0, 0, 4626, 57696, -23973, 54334, -5859, 0,
> 0, 0, -3543, -44244, 18393, -41664, 4492, 0, 0, 0, 0, 0, 0, 0, 0, 1,
> 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 ]) >;
>
> IsAbelian (G);
true
> IsCompletelyReducible (G);
true
>
> I, phi, tau := RecogniseAbelian (G);
> I;
GrpGPC : I of infinite order on 3 PC-generators
PC-Relations:
> phi;
Mapping from: GL(8, RationalField()) to GrpGPC: I given by a rule [no inverse]
> tau;
Mapping from: GrpGPC: I to GrpMat: G given by a rule [no inverse]
> images := [phi (G.i): i in [1..Ngens (G)]];
> "images of matrix generators are ", images;
images of matrix generators are [ I.3, I.1, I.1^-1, I.2 ]
>
> "Preimage of I.1 is ", tau (I.1);
Preimage of I.1 is
[-6371 -304884 123147 -274455 -2268 0 0 0]
[-6741 -91988 31500 -341397/4 3591 0 0 0]
[1764 103896 -42443 93312 1134 0 0 0]
[8442 157356 -57510 144370 -3402 0 0 0]
[-378 -112644 47817 -100359 -2591 0 0 0]
[0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 1 0]
[0 0 0 0 0 0 0 1]
```
#### `Example: Sylow System of a Nilpotent Group (ex-644306)`
```magma
> M:= MatrixAlgebra (GF(17), 4);
> a:= M![5, 5, 3, 3, 0, 5, 0, 3, 16, 16, 14, 14, 0, 16, 0, 14];
> b:= M![9, 9, 0, 0, 0, 9, 0, 0, 10, 10, 8, 8, 0, 10, 0, 8];
> G:= sub;
> IsNilpotent(G);
true
> SylowSystem (G);
[
MatrixGroup(4, GF(17))
Generators:
[ 5 0 3 0]
[ 0 5 0 3]
[16 0 14 0]
[ 0 16 0 14]
[ 9 0 0 0]
[ 0 9 0 0]
[10 0 8 0]
[ 0 10 0 8],
MatrixGroup(4, GF(17))
Generators:
[ 1 1 0 0]
[ 0 1 0 0]
[ 0 0 1 1]
[ 0 0 0 1]
]
> Order(G);
8704
```
#### `Example: Infinite Nilpotent Group over a Function Field (ex-8207b7)`
```magma
> R:= QuadraticField(-1);
> F:= FunctionField(R);
> M:= MatrixAlgebra (F, 2);
> a:= M![-s*t^2 + 1, s*t^3, -s*t, s*t^2 + 1];
> b:= M![t^2 - 3*t + 1, 0, 0, t^2 - 3*t + 1];
> G:= sub;
> IsNilpotent(G);
true
> IsFinite(G);
false
```
## Matrix Groups over Q and Z
- [Overview](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Overview.md)
- [Invariant Forms](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/forms.md)
- [`PositiveDefiniteForm(G): GrpMat → Mtrx`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/forms.md#function-grpmatqz-positivedefiniteform)
- [`InvariantForms(G): GrpMat → [ AlgMatElt ]`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/forms.md#function-invariantforms-grpmat)
- [`SymmetricForms(G): GrpMat → [ AlgMatElt ]`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/forms.md#function-symmetricforms-grpmat)
- [`AntisymmetricForms(G): GrpMat → [ AlgMatElt ]`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/forms.md#function-antisymmetricforms-grpmat)
- [`InvariantForms(G, n): GrpMat, RngIntElt → [ AlgMatElt ]`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/forms.md#function-invariantforms-grpmat-rngintelt)
- [`SymmetricForms(G, n): GrpMat, RngIntElt → [ AlgMatElt ]`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/forms.md#function-symmetricforms-grpmat-rngintelt)
- [`AntisymmetricForms(G, n): GrpMat, RngIntElt → [ AlgMatElt ]`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/forms.md#function-antisymmetricforms-grpmat-rngintelt)
- [`NumberOfInvariantForms(G): GrpMat → RngIntElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/forms.md#function-numberofinvariantforms-grpmat)
- [`NumberOfSymmetricForms(G): GrpMat → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/forms.md#function-numberofsymmetricforms-grpmat)
- [`NumberOfAntisymmetricForms(G): GrpMat → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/forms.md#function-numberofantisymmetricforms-grpmat)
- [Endomorphisms](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Endomorphisms.md)
- [`EndomorphismRing(G): GrpMat → AlgMat`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Endomorphisms.md#function-endomorphismring-grpmat)
- [`EndomorphismAlgebra(G): GrpMat → AlgMat`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Endomorphisms.md#function-endomorphismalgebra-grpmat)
- [`CentreOfEndomorphismRing(G): GrpMat → AlgMat`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Endomorphisms.md#function-centreofendomorphismring-grpmat)
- [`CentreOfEndomorphismAlgebra(G): GrpMat → AlgMat`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Endomorphisms.md#function-centreofendomorphismalgebra-grpmat)
- [`DimensionOfEndomorphismRing(G): GrpMat → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Endomorphisms.md#function-dimensionofendomorphismring-grpmat)
- [`DimensionOfCentreOfEndomorphismRing(G): GrpMat → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Endomorphisms.md#function-dimensionofcentreofendomorphismring-grpmat)
- [`Endomorphisms(G, n): GrpMat, RngIntElt → [ AlgMatElt ]`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Endomorphisms.md#function-endomorphisms-grpmat-rngintelt)
- [`CentralEndomorphisms(G, n): GrpMat, RngIntElt → [ AlgMatElt ]`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Endomorphisms.md#function-centralendomorphisms-grpmat-rngintelt)
- [New Groups From Others](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Others.md)
- [`BravaisGroup(G): GrpMat[RngInt] → GrpMat`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Others.md#function-bravaisgroup-grpmat-rngint)
- [`IntegralGroup(G): GrpMat → GrpMat, AlgMatElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Others.md#function-integralgroup-grpmat)
- [`IntegralGroup(G): [Mtrx] → [Mtrx], AlgMatElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Others.md#function-integralgroup-mtrx)
- [Perfect Forms and Normalizers](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Normalizer.md)
- [`PerfectForms(G): GrpMat[RngInt] → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Normalizer.md#function-perfectforms-grpmat-rngint)
- [`NormalizerGLZ(G): GrpMat[RngInt] → GrpMat[RngInt]`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Normalizer.md#function-normalizerglz-grpmat-rngint)
- [`CentralizerGLZ(G): GrpMat[RngInt] → GrpMat[RngInt]`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Normalizer.md#function-centralizerglz-grpmat-rngint)
- [Conjugacy](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Conjugacy.md)
- [`ZClasses(G): GrpMat → SeqEnum, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Conjugacy.md#function-zclasses-grpmat)
- [`IsGLZConjugate(G, H): GrpMat[RngInt], GrpMat[RngInt] → BoolElt, GrpMatElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Conjugacy.md#function-isglzconjugate-grpmat-rngint-grpmat-rngint)
- [`IsBravaisEquivalent(G, H): GrpMat[RngInt], GrpMat[RngInt] → BoolElt, GrpMatElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Conjugacy.md#function-isbravaisequivalent-grpmat-rngint-grpmat-rngint)
- [`IsGLQConjugate(G, H): GrpMat, GrpMat → BoolElt, GrpMatElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Conjugacy.md#function-isglqconjugate-grpmat-grpmat)
- [Conjugacy Tests for Matrices](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Conjugacy_Matrices.md)
- [`IsGLZConjugate(A, B): AlgMatElt, AlgMatElt → BoolElt, GrpMatElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Conjugacy_Matrices.md#function-isglzconjugate-algmatelt-algmatelt)
- [`IsGLZConjugate(A, B): GrpMatElt, GrpMatElt → BoolElt, GrpMatElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Conjugacy_Matrices.md#function-isglzconjugate-grpmatelt-grpmatelt)
- [`IsSLZConjugate(A, B): AlgMatElt, AlgMatElt → BoolElt, GrpMatElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Conjugacy_Matrices.md#function-isslzconjugate-algmatelt-algmatelt)
- [`IsSLZConjugate(A, B): GrpMatElt, GrpMatElt → BoolElt, GrpMatElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Conjugacy_Matrices.md#function-isslzconjugate-grpmatelt-grpmatelt)
- [`CentralizerGLZ(A): AlgMatElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Conjugacy_Matrices.md#function-centralizerglz-algmatelt)
- [`CentralizerGLZ(A): GrpMatElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Conjugacy_Matrices.md#function-centralizerglz-grpmatelt)
- [`AreGLConjugate(A, B : parameters): AlgMatElt, AlgMatElt → BoolElt, AlgMatElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Conjugacy_Matrices.md#function-areglconjugate-algmatelt-algmatelt)
- [`AreGLConjugate(A, B : parameters): GrpMatElt, GrpMatElt → BoolElt, GrpMatElt`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Conjugacy_Matrices.md#function-areglconjugate-grpmatelt-grpmatelt)
- [`GLCentraliser(A : parameters): AlgMatElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Conjugacy_Matrices.md#function-glcentraliser-algmatelt)
- [`GLCentraliser(A : parameters): GrpMatElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Conjugacy_Matrices.md#function-glcentraliser-grpmatelt)
- [Examples](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Examples.md)
- [Example: Integral Classes of a Dihedral Representation](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Examples.md#example-ex-000ead)
- [Example: Rational but Not Integral Conjugacy](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Examples.md#example-ex-0cc747)
- [Example: Unimodular Conjugating Matrix](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Examples.md#example-ex-7ed711)
- [Example: Integral Conjugacy and Centralisers](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/Examples.md#example-ex-2c3b15)
- [Bibliography](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverQAndZ/bibliography.md)
### Overview
In addition to the functionality explained in Chapter [Matrix Groups over Infinite Fields](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverInfiniteFields/index-matrix-groups-over-infinite-fields.md#grpmatinf) and the functions that are available for all finite (matrix) groups, Magma can also compute normalizers and centralizers of a finite integral matrix group $G$ in ${\operatorname{GL}}_n({\mathbb{Z}})$ as well as decide conjugacy in ${\operatorname{GL}}_n({\mathbb{Z}})$ and ${\operatorname{GL}}_n({\mathbb{Q}})$.
These algorithms are based on the sublattice machinery (see Section [$G$-invariant Sublattices](https://docs.magma-maths.org/LatticesQuadraticForms/LatticesWithGroupAction/G-lattices.md#glat-sublattices)) and the enumeration of $G$-perfect forms. They are explained in [[Opg01](https://docs.magma-maths.org/references.md#cite-opgenorth), [OPS98](https://docs.magma-maths.org/references.md#cite-plesken-acta)]. The algorithms perform very well, as long as the space of $G$-invariant symmetric forms has small dimension (say less than 15) and the index of the groups in their Bravais groups is not too large.
The databases of maximal finite irreducible rational, integral, symplectic, and quaternionic matrix groups are explained in Chapter [Databases of Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/index-databases-of-groups.md#chapgrpdata).
### Invariant Forms
Let $G$ be a finite matrix group $G < {\operatorname{GL}}_n({\mathbb{Q}})$. A matrix $F \in M_n({\mathbb{Q}})$ is $G$-invariant if $gFg^{tr} = F$ for all $g \in G$.
#### `PositiveDefiniteForm(G): GrpMat -> Mtrx`
For a finite integral or rational matrix group $G$, return a positive definite symmetric $G$-invariant form.
#### `InvariantForms(G): GrpMat -> [ AlgMatElt ]`
#### `SymmetricForms(G): GrpMat -> [ AlgMatElt ]`
#### `AntisymmetricForms(G): GrpMat -> [ AlgMatElt ]`
For an integral or rational matrix group $G$, return a basis for the space of $G$-linear forms or for the subspace of (anti-) symmetric forms respectively.
The first form returned by `InvariantForms` and `SymmetricForms` will be positive definite.
#### `InvariantForms(G, n): GrpMat, RngIntElt -> [ AlgMatElt ]`
#### `SymmetricForms(G, n): GrpMat, RngIntElt -> [ AlgMatElt ]`
#### `AntisymmetricForms(G, n): GrpMat, RngIntElt -> [ AlgMatElt ]`
For an integral or rational matrix group $G$, return a sequence consisting of $n\geq 0$ $G$-invariant (symmetric or antisymmetric) bilinear forms for $G$.
#### `NumberOfInvariantForms(G): GrpMat -> RngIntElt, RngIntElt`
#### `NumberOfSymmetricForms(G): GrpMat -> RngIntElt`
#### `NumberOfAntisymmetricForms(G): GrpMat -> RngIntElt`
For an integral or rational matrix group $G$ or a $G$-lattice $L$, return the dimension of the space of (symmetric or anti-symmetric) invariant bilinear forms for $G$.
The algorithm uses a modular method which is much faster than the actual computation of the forms.
### Endomorphisms
#### `EndomorphismRing(G): GrpMat -> AlgMat`
#### `EndomorphismAlgebra(G): GrpMat -> AlgMat`
For an integral or rational matrix group $G$, return the endomorphism ring (i.e. the commuting algebra) of $G$ as a subalgebra of $M_n({\mathbb{Z}})$ or $M_n({\mathbb{Q}})$ respectively.
#### `CentreOfEndomorphismRing(G): GrpMat -> AlgMat`
#### `CentreOfEndomorphismAlgebra(G): GrpMat -> AlgMat`
For an integral or rational matrix group $G$, return the center of the endomorphism ring (i.e. the commuting algebra) of $G$ as a subalgebra of $M_n({\mathbb{Z}})$ or $M_n({\mathbb{Q}})$ respectively.
#### `DimensionOfEndomorphismRing(G): GrpMat -> RngIntElt`
Return the dimension of the endomorphism ring of an integral or rational matrix group $G$ by a modular method.
#### `DimensionOfCentreOfEndomorphismRing(G): GrpMat -> RngIntElt`
Return the dimension of the centre of the endomorphism ring of an integral or rational matrix group $G$ by a modular method.
#### `Endomorphisms(G, n): GrpMat, RngIntElt -> [ AlgMatElt ]`
For an integral or rational matrix group $G$, return a sequence containing $n$ independent endomorphisms of $G$. $n$ must be in the range $[0 .. d]$, where $d$ is the dimension of the endomorphism ring of $G$.
#### `CentralEndomorphisms(G, n): GrpMat, RngIntElt -> [ AlgMatElt ]`
For an integral or rational matrix group $G$, return a sequence containing $n$ independent central endomorphisms of $G$. $n$ must be in the range $[0 .. d]$, where $d$ is the dimension of the centre of the endomorphism ring of $G$.
### New Groups From Others
#### `BravaisGroup(G): GrpMat[RngInt] -> GrpMat`
For a finite integral matrix group $G$, compute its Bravais group which is the integral group fixing all symmetric bilinear forms fixed by $G$.
#### `IntegralGroup(G): GrpMat -> GrpMat, AlgMatElt`
#### `IntegralGroup(G): [Mtrx] -> [Mtrx], AlgMatElt`
Return the action of the finite rational matrix group $G$ on an invariant lattice as an integral matrix group, thus giving an equivalent integral group $H$, together with the transformation matrix $T$ from the standard lattice to the invariant lattice. Thus $H = T\cdot G\cdot T^{-1}$.
### Perfect Forms and Normalizers
#### `PerfectForms(G): GrpMat[RngInt] -> SeqEnum`
```magma
Limit: RngIntElt Default: Infinity()
```
A positive definite symmetric $G$-invariant form $F$ is called $G$-perfect if for every nonzero symmetric $G$-invariant form $F'$ there exists some shortest vector $x$ of $F$ such that $F'x^{tr}x$ has nonzero trace.
The normalizer of the Bravais group of $G$ in ${\operatorname{GL}}_n({\mathbb{Z}})$ acts on the set of integral $G$-perfect forms whose entries have GCD $1$ and the number of orbits is finite. This function returns a sequence of representatives of these orbits.
If `Limit` is set to a positive integer $m$, then the algorithm stops after $m$ orbits have been enumerated.
#### `NormalizerGLZ(G): GrpMat[RngInt] -> GrpMat[RngInt]`
#### `CentralizerGLZ(G): GrpMat[RngInt] -> GrpMat[RngInt]`
```magma
IsBravais: BoolElt Default: false
```
Given a finite subgroup $G$ of ${\operatorname{GL}}_n({\mathbb{Z}})$, returns the normalizer or centralizer of $G$ in ${\operatorname{GL}}_n({\mathbb{Z}})$.
If $G$ is known to be equal to its Bravais group, one can set `IsBravais` to `true` to speed up the computation.
The algorithm employed is a variation of Opgenorth’s normalizer algorithm [[Opg01](https://docs.magma-maths.org/references.md#cite-opgenorth)].
### Conjugacy
#### `ZClasses(G): GrpMat -> SeqEnum, SeqEnum`
```magma
Homogeneously: BoolElt Default: false
```
Given a finite integral or rational matrix group $G$, its ${\operatorname{GL}}_n({\mathbb{Q}})$-conjugacy class splits into finitely many ${\operatorname{GL}}(n,{\mathbb{Z}})$-conjugacy classes. Representatives of these classes are constructed as the action of $G$ on some $G$-invariant sublattices. More precisely, the ${\operatorname{GL}}(n,{\mathbb{Z}})$-conjugacy classes are in bijection with the orbits of $G$-invariant lattices under the normalizer $N$ of $G$ in ${\operatorname{GL}}(n, {\mathbb{Q}})$.
A $G$-lattice $L'$ belongs to a $G$-lattice $L$ if $L = \sum_i L' e_i$ where $e_1,\dots,e_r$ denote the central idempotents of the endomorphism ring of $G$. Further, $L$ is called *homogeneously decomposable* if $L$ belongs to itself.
The algorithm will first compute representatives $L_1, \dots,L_k$ of the orbits of homogeneously decomposable $G$-lattices under the action of $N$.
In a second step, it will then compute the $G$-lattices $L_{i, j}$ belonging to $L_i$ up to the action of $N$.
The second return value will then consist of a sequence of $k$ sequences $T_1,\dots,T_k$. The first element $T_i[1]$ is the basis matrix of $L_i$, the following entries are basis matrices of the lattices $L_{i, j}$.
The first return value is a sequence of integral matrix groups describing the action of $G$ on the lattices $L_{1,1}, L_{1,2}, \dots$. Hence these groups correspond to the ${\operatorname{GL}}_n({\mathbb{Z}})$-conjugacy classes of $G$.
If `Homogeneously` is set to `true`, the function will only compute the homogeneously decomposable lattices $L_1,\dots, L_k$ and the corresponding matrix groups. (If $G$ is reducible, this option is much faster, but will not yield all conjugacy classes / orbits of lattices.)
#### `IsGLZConjugate(G, H): GrpMat[RngInt], GrpMat[RngInt] -> BoolElt, GrpMatElt`
Tests whether the finite integral matrix groups $G$ and $H$ are conjugate in ${\operatorname{GL}}_n({\mathbb{Z}})$. If so, a matrix $x$ such that $G^x = H$ is also returned.
#### `IsBravaisEquivalent(G, H): GrpMat[RngInt], GrpMat[RngInt] -> BoolElt, GrpMatElt`
Given two finite integral matrix groups $G$ and $H$, tests whether their Bravais groups $B(G)$ and $B(H)$ are conjugate in ${\operatorname{GL}}_n({\mathbb{Z}})$. If so, a matrix $x$ such that $B(G)^x = B(H)$ is also returned.
Note that this function does not need to compute the Bravais groups and hence it is faster than calling `IsGLZConjugate` on the Bravais groups directly.
If $G$ and $H$ are known to be Bravais groups, this function is usually more efficient than calling `IsGLZConjugate`.
#### `IsGLQConjugate(G, H): GrpMat, GrpMat -> BoolElt, GrpMatElt`
```magma
Al: MonStgElt Default:
```
Tests whether the finite rational matrix groups $G$ and $H$ are conjugate in ${\operatorname{GL}}_n({\mathbb{Q}})$. If so, a matrix $x$ such that $G^x = H$ is also returned.
There are currently two algorithms available. If the optional parameter `Al` equals `"Aut"`, Magma will use the `GModule`-machinery together with the outer automorphism group of $H$. If `Al` is set to `"ZClasses"`, Magma splits the ${\operatorname{GL}}(n, {\mathbb{Q}})$-conjugacy class of $H$ into ${\operatorname{GL}}_n({\mathbb{Z}})$-conjugacy classes and then decides whether an integral copy of $G$ lies in one of these classes by several calls to `IsGLZConjugate`.
If `Al` is not provided, a sensible choice is made by the system.
### Conjugacy Tests for Matrices
Given two $n \times n$ matrices $A$ and $B$ with rational or integral entries, Magma can test whether $A$ is conjugate to $B$ in ${\operatorname{GL}}_n(Z)$.
Two algorithms are available for this task. Currently, the implementation of the first is limited to the cases where $A,B$ have finite order or where $n=2$. This limitation will be removed in future versions.
#### `IsGLZConjugate(A, B): AlgMatElt, AlgMatElt -> BoolElt, GrpMatElt`
#### `IsGLZConjugate(A, B): GrpMatElt, GrpMatElt -> BoolElt, GrpMatElt`
#### `IsSLZConjugate(A, B): AlgMatElt, AlgMatElt -> BoolElt, GrpMatElt`
#### `IsSLZConjugate(A, B): GrpMatElt, GrpMatElt -> BoolElt, GrpMatElt`
Tests whether two rational or integral matrices $A$ and $B$ are conjugate in ${\operatorname{GL}}_n({\mathbb{Z}})$ or ${\operatorname{SL}}_n({\mathbb{Z}})$. If so, a matrix $x$ such that $A^x = B$ is also returned.
#### `CentralizerGLZ(A): AlgMatElt -> GrpMat`
#### `CentralizerGLZ(A): GrpMatElt -> GrpMat`
Given a rational or integral matrix $A$, this function returns its centralizer in ${\operatorname{GL}}_n({\mathbb{Z}})$. The current implementation is limited to the cases where either $A$ has finite order or $A$ is a $2\times 2$ matrix.
The second algorithm to decide conjugacy in ${\operatorname{GL}}_n({\mathbb{Z}})$ was developed by Eick, Hofmann, and O’Brien [[EHO19](https://docs.magma-maths.org/references.md#cite-eick-hofmann-obrien)] and it does *not* assume that the matrices have finite order. The implementation was prepared by the authors; it incorporates code prepared by David Husert [[Hus16](https://docs.magma-maths.org/references.md#cite-husert16)] for the special case where the matrices are either nilpotent or have irreducible characteristic polynomials. It also uses Sebastian Schönnenbeck’s implementation of an algorithm of Voronoi to compute unit groups of orders.
#### `AreGLConjugate(A, B : parameters): AlgMatElt, AlgMatElt -> BoolElt, AlgMatElt`
#### `AreGLConjugate(A, B : parameters): GrpMatElt, GrpMatElt -> BoolElt, GrpMatElt`
```magma
UseHusert: BoolElt Default: true
GRH : BoolElt Default: true
```
Tests whether two integral or rational matrices $A$ and $B$ are conjugate in ${\operatorname{GL}}_n({\mathbb{Z}})$. If so, a matrix $x$ such that $A^x = B$ is also returned.
If `UseHusert` is `true` then use Husert’s algorithm for matrices that are either nilpotent or have irreducible characteristic polynomials.
If `GRH` is `true` then assume the generalised Riemann hypothesis holds. This impacts on the efficiency of the algorithm: a positive answer is always verifiable since the algorithm returns a conjugating element.
#### `GLCentraliser(A : parameters): AlgMatElt -> GrpMat`
#### `GLCentraliser(A : parameters): GrpMatElt -> GrpMat`
```magma
GRH: BoolElt Default: true
```
Given an integral or rational matrix $A$, this function returns its centralizer in ${\operatorname{GL}}_n({\mathbb{Z}})$. The optional parameter is as defined for `AreGLConjugate`.
The verbose flag `SetVerbose ("GLConjugacy", n)` where $n = 0, 1, 2$ will provide information on the progress of the algorithms.
### Examples
#### `Example: Integral Classes of a Dihedral Representation (ex-000ead)`
We split the ${\operatorname{GL}}_3({\mathbb{Q}})$-conjugacy class of the following faithful representation of the dihedral group with $12$ elements.
```magma
> G := MatrixGroup< 3, Integers() |
> [ 1, -1, 0, 0, -1, 0, 0, 0, 1 ],
> [ 1, -1, 0, 1, 0, 0, 0, 0, -1 ] >;
> Z, T:= ZClasses(G);
> #Z;
3
> < #t : t in T >;
<1, 2>
```
So there are 2 classes of homogeneously decomposable lattices represented by `T[1,1]` and `T[2,1]`. The third lattice `T[2,2]` belongs to `T[2,1]` as we check.
```magma
> Q := Rationals();
> GQ := ChangeRing(G, Q);
> Ids := CentralIdempotents(EndomorphismRing(GQ));
> L := VerticalJoin([ Matrix(Integers(), T[2,2] * i) : i in Ids]);
> Image(L) eq Image(Matrix(Integers(), T[2,1]));
true
```
Finally, we check that the $3$ ${\operatorname{GL}}_3({\mathbb{Z}})$-conjugacy classes stored in `Z` correspond to the $3$ lattices in `T`.
```magma
> TT := &cat T;
> [ GQ eq ChangeRing(Z[i], Q)^(GL(3, Q) ! TT[i]) : i in [1..#Z] ];
[ true, true, true ]
```
#### `Example: Rational but Not Integral Conjugacy (ex-0cc747)`
We test that the automorphism groups of the lattices $B_{8}$ and $D_{8}$ are conjugate in ${\operatorname{GL}}_{8}({\mathbb{Q}})$ but not in ${\operatorname{GL}}_{8}({\mathbb{Z}})$.
```magma
> G := AutomorphismGroup( Lattice("B", 8) );
> H := AutomorphismGroup( Lattice("D", 8) );
> ok, x := IsGLQConjugate(G, H); ok, x;
true
[ 1 -1 0 0 0 0 0 0]
[ 1 -1 -2 0 0 0 0 0]
[-1 1 2 2 2 2 2 2]
[ 1 1 0 0 0 0 0 0]
[-1 1 2 2 2 2 2 0]
[ 1 -1 -2 -2 -2 0 0 0]
[-1 1 2 2 2 2 0 0]
[-1 1 2 2 0 0 0 0]
> Determinant(x);
-128
> IsGLZConjugate(G,H);
false
```
#### `Example: Unimodular Conjugating Matrix (ex-7ed711)`
Let $C$ be the companion matrix of the fifth cyclotomic polynomial. We find a unimodular matrix that induces the automorphism $C -> C^2$.
```magma
> C:= CompanionMatrix(CyclotomicPolynomial(5));
> ok, h:= IsGLZConjugate(C, C^2); ok;
true
> C^2 eq h^-1 * C * h;
true
```
We now check by hand that this automorphism cannot be realized by a matrix of determinant $1$.
```magma
> Determinant(h);
-1
> G:= CentralizerGLZ(C);
> [ Determinant(g) : g in Generators(G) ];
[1, 1, 1]
```
Of course, we could also just ask:
```magma
> IsSLZConjugate(C, C^2);
false
```
#### `Example: Integral Conjugacy and Centralisers (ex-2c3b15)`
We use the algorithm of Eick *et al.* [[EHO19](https://docs.magma-maths.org/references.md#cite-eick-hofmann-obrien)] to decide integral conjugacy and to construct integral centralisers.
```magma
> A := GL(4, Integers ())!
> [ 1, 0, 0, -3, 1, 1, -4, -3,
> 0, 0, -1, 0, 5, 5, -21, -14 ];
> B := GL(4, Integers ())!
> [-104, -21, -8, -3, 7729, 1552, 253, 218,
> 0, 0, -1, 0, -51848, -10407, -1532, -1460 ];
> flag, C := AreGLConjugate (A, B);
> flag;
true
> assert C^-1 * A * C eq B;
> C := GLCentraliser (A);
> assert forall{c * A eq A * c: c in Generators (C)};
>
> // another example with rational entries
> Q := Rationals ();
> A := GL(3,Q)!
> [ -5/3, -13/3, 25/3,
> -7/3, 19/3, -16/3,
> -5/3, 5/3, -2/3 ];
> B := GL(3, Q) !
> [ -19/3, -21, -119/3,
> -1, 1, -2,
> 5/3, 5, 28/3 ];
> f, C := AreGLConjugate (A, B);
> C;
[ 1 2 4]
[ 0 -1 -2]
[ 0 0 -1]
> C := GL(3, Q) ! C;
> assert A^C eq B;
> C := GLCentraliser (A);
> C := sub;
> assert forall{c * A eq A * c: c in Generators (C)};
```
## Finite Soluble Groups
- [Introduction](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/introduction.md)
- [Power-Conjugate Presentations](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/introduction.md#power-conjugate-presentations)
- [Creation of a Group](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/definition.md)
- [Construction Functions](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/definition.md#construction-functions)
- [`CyclicGroup(GrpPC, n): Cat, RngIntElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/definition.md#function-cyclicgroup-cat-rngintelt)
- [`AbelianGroup(GrpPC, Q): Cat, [RngIntElt] → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/definition.md#function-abeliangroup-cat-rngintelt)
- [`DihedralGroup(GrpPC, n): Cat, RngIntElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/definition.md#function-dihedralgroup-cat-rngintelt)
- [`ExtraSpecialGroup(GrpPC, p, n : parameters): Cat, RngIntElt, RngIntElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/definition.md#function-extraspecialgroup-cat-rngintelt-rngintelt)
- [Example: Pc-Representation of a Cyclic Group](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/definition.md#example-ex-a851f0)
- [Definition by Presentation](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/definition.md#definition-by-presentation)
- [`PolycyclicGroup< x₁, ..., xₙ | R : parameters >: List(Identifiers), List(GrpFPRel) → GrpPC, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/definition.md#constructor-constructor-polycyclicgroup-list-identifiers-list-grpfprel-grppc-map)
- [`quo< GrpPC : F | R : parameters >: GrpFP, List(GrpFPRel) → GrpPC, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/definition.md#constructor-constructor-quo-grpfp-list-grpfprel-grppc-map)
- [Example: Group of Order 80 from a Presentation](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/definition.md#example-ex-a8ae01)
- [Possibly Inconsistent Presentations](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/definition.md#possibly-inconsistent-presentations)
- [`IsConsistent(G): GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/definition.md#function-isconsistent-grppc)
- [Example: Checking Consistency of Presentations](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/definition.md#example-ex-a62513)
- [Basic Group Properties](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md)
- [Infrastructure](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#infrastructure)
- [`G . i: GrpPC, RngIntElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#operation-operation-grppc-rngintelt-grppcelt)
- [`Generators(G): GrpPC → SetEnum`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-generators-grppc)
- [`NumberOfGenerators(G): GrpPC → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-numberofgenerators-grppc)
- [`Ngens(G): GrpPC → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-ngens-grppc)
- [`PCGenerators(G): GrpPC → SetIndx`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-pcgenerators-grppc)
- [`NumberOfPCGenerators(G): GrpPC → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-numberofpcgenerators-grppc)
- [`NPCGenerators(G): GrpPC → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-npcgenerators-grppc)
- [`NPCgens(G): GrpPC → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-npcgens-grppc)
- [`PCPrimes(G): GrpPC → [RngIntElt]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-pcprimes-grppc)
- [Numerical Invariants](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#numerical-invariants)
- [`Order(G): GrpPC → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-order-grppc)
- [`# G: GrpPC → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#operation-operation-grppc-rngintelt)
- [`FactoredOrder(G): GrpPC → []`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-factoredorder-grppc)
- [`Exponent(G): GrpPC → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-exponent-grppc)
- [Predicates](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#predicates)
- [`IsAbelian(G): GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-isabelian-grppc)
- [`IsCyclic(G): GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-iscyclic-grppc)
- [`IsElementaryAbelian(G): GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-iselementaryabelian-grppc)
- [`IsNilpotent(G): GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-isnilpotent-grppc)
- [`IsPerfect(G): GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-isperfect-grppc)
- [`IsSimple(G): GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-issimple-grppc)
- [`IsSoluble(G): GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-issoluble-grppc)
- [`IsSolvable(G): GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-issolvable-grppc)
- [`IsTrivial(G): GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-istrivial-grppc)
- [`IsSpecial(G): GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-isspecial-grppc)
- [`IsExtraSpecial(G): GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#function-isextraspecial-grppc)
- [Example: Basic Properties of Pc-Groups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/group-properties.md#example-ex-e86fe2)
- [Homomorphisms](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/homomorphisms.md)
- [`hom< G -> H | L >: GrpPC, GrpPC, List → Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/homomorphisms.md#constructor-constructor-hom-grppc-grppc-list-map)
- [`IsHomomorphism(G, H, L): GrpPC, GrpPC, SeqEnum → BoolElt, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/homomorphisms.md#function-ishomomorphism-grppc-grppc-seqenum)
- [`IsHomomorphism(G, H, L): GrpPC, GrpPC, SetEnum[Tup] → BoolElt, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/homomorphisms.md#function-ishomomorphism-grppc-grppc-setenum-tup)
- [`IdentityHomomorphism(G): GrpPC → Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/homomorphisms.md#function-identityhomomorphism-grppc)
- [`Kernel(f): Map → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/homomorphisms.md#function-kernel-map)
- [`Homomorphisms(G, H): GrpPC, GrpPC → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/homomorphisms.md#function-homomorphisms-grppc-grppc)
- [Example: Homomorphisms Between Pc-Groups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/homomorphisms.md#example-ex-d63f2e)
- [New Groups from Existing](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/extension.md)
- [`DirectProduct(G, H): GrpPC, GrpPC → GrpPC, [Map], [Map]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/extension.md#function-directproduct-grppc-grppc)
- [`DirectProduct(Q): [GrpPC] → GrpPC, [ Map ], [ Map ]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/extension.md#function-directproduct-grppc)
- [`Extension(G, H, f): GrpPC, GrpPC, [Map] → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/extension.md#function-extension-grppc-grppc-map)
- [`Extension(M, H): ModGrp, GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/extension.md#function-extension-modgrp-grppc)
- [`Extension(G, H, f, t): GrpPC, GrpPC, [Map], [GrpPCElt] → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/extension.md#function-extension-grppc-grppc-map-grppcelt)
- [`Extension(G, H, f, t): GrpPC, GrpPC, [Map], {Tup} → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/extension.md#function-extension-grppc-grppc-map-tup)
- [`Extension(M, H, t): ModGrp, GrpPC, [ModGrpElt] → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/extension.md#function-extension-modgrp-grppc-modgrpelt)
- [`IsExtension(G, H, f): GrpPC, GrpPC, [Map] → BoolElt, GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/extension.md#function-isextension-grppc-grppc-map)
- [`IsExtension(M, H): ModGrp, GrpPC → BoolElt, GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/extension.md#function-isextension-modgrp-grppc)
- [`IsExtension(G, H, f, t): GrpPC, GrpPC, [Map], [GrpPCElt] → BoolElt, GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/extension.md#function-isextension-grppc-grppc-map-grppcelt)
- [`IsExtension(G, H, f, t): GrpPC, GrpPC, [Map], {Tup} → BoolElt, GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/extension.md#function-isextension-grppc-grppc-map-tup)
- [`IsExtension(M, H, t): ModGrp, GrpPC, [ModGrpElt] → BoolElt, GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/extension.md#function-isextension-modgrp-grppc-modgrpelt)
- [`WreathProduct(G, H): GrpPC, GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/extension.md#function-wreathproduct-grppc-grppc)
- [`WreathProduct(G, H, f): GrpPC, GrpPC, Map → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/extension.md#function-wreathproduct-grppc-grppc-map)
- [`WreathProduct(G, H, f): GrpPC, GrpPC, [GrpPermElt] → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/extension.md#function-wreathproduct-grppc-grppc-grppermelt)
- [Example: Extensions of an Elementary Abelian Group](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/extension.md#example-ex-73458c)
- [Example: Cossey-Hawkes Conjugacy Class Sizes](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/extension.md#example-ex-9a45eb)
- [Elements](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md)
- [Definition of Elements](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#definition-of-elements)
- [`G ! Q: GrpPC, [RngIntElt] → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#operation-op-grppc-rngintelt)
- [`ElementToSequence(x): GrpPCElt → [RngIntElt]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#function-elementtosequence-grppcelt)
- [`Eltseq(x): GrpPCElt → [RngIntElt]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#function-eltseq-grppcelt)
- [`Identity(G): GrpPC → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#function-identity-grppc)
- [`Id(G): GrpPC → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#function-id-grppc)
- [`G ! 1: GrpPC, RngIntElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#operation-op-grppc-rngintelt-2)
- [Example: Defining Elements of a Pc-Group](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#example-ex-027472)
- [Arithmetic Operations on Elements](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#arithmetic-operations-on-elements)
- [`g * h: GrpPCElt, GrpPCElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#operation-op-times-grppcelt-grppcelt)
- [`g *:= h: GrpPCElt, GrpPCElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#operation-operation-grppcelt-grppcelt-grppcelt)
- [`g ^ n: GrpPCElt, RngIntElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#operation-op-pow-grppcelt-rngintelt)
- [`g ^:= n: GrpPCElt, RngIntElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#operation-operation-grppcelt-rngintelt-grppcelt)
- [`g / h: GrpPCElt, GrpPCElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#operation-op-div-grppcelt-grppcelt)
- [`g /:= h: GrpPCElt, GrpPCElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#operation-operation-grppcelt-grppcelt-grppcelt-2)
- [`g ^ h: GrpPCElt, GrpPCElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#operation-op-pow-grppcelt-grppcelt)
- [`g ^:= h: GrpPCElt, GrpPCElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#operation-operation-grppcelt-grppcelt-grppcelt-3)
- [`(g₁, ..., gₙ): List(GrpPCElt) → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#literal-literal-g1-gn-list-grppcelt-grppcelt)
- [Properties of Elements](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#properties-of-elements)
- [`Order(x): GrpPCElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#function-order-grppcelt)
- [`Parent(x): GrpPCElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#function-parent-grppcelt)
- [Predicates for Elements](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#predicates-for-elements)
- [`g eq h: GrpPCElt, GrpPCElt → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#operation-op-eq-grppcelt-grppcelt)
- [`g ne h: GrpPCElt, GrpPCElt → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#operation-op-ne-grppcelt-grppcelt)
- [`IsIdentity(g): GrpPCElt → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#function-isidentity-grppcelt)
- [`IsId(g): GrpPCElt → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#function-isid-grppcelt)
- [`IsConjugate(G, g, h): GrpPC, GrpPCElt, GrpPCElt → BoolElt, GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#function-isconjugate-grppc-grppcelt-grppcelt)
- [Example: Testing Whether Elements Commute](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#example-ex-7b7701)
- [Set Operations](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#set-operations)
- [`NumberingMap(G): GrpPC → Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#function-numberingmap-grppc)
- [`Random(G): GrpPC → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#function-random-grppc)
- [`RandomProcess(G): GrpPC → Process`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#function-randomprocess-grppc)
- [`Random(P): Process → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#function-random-process)
- [`Representative(G): GrpPC → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#function-representative-grppc)
- [`Rep(G): GrpPC → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#function-rep-grppc)
- [Example: Numbering Group Elements](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#example-ex-0f7a7b)
- [Example: Set Product of Two Subgroups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elements.md#example-ex-91703e)
- [Conjugacy](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elt-conjugacy.md)
- [`Class(H, g): GrpPC, GrpPCElt → { GrpPCElt}`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elt-conjugacy.md#function-class-grppc-grppcelt)
- [`Conjugates(H, g): GrpPC, GrpPCElt → { GrpPCElt}`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elt-conjugacy.md#function-conjugates-grppc-grppcelt)
- [`g ^ H: GrpPCElt, GrpPC → { GrpPCElt}`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elt-conjugacy.md#operation-op-pow-grppcelt-grppc)
- [`ConjugacyClasses(G): GrpPC → [ ]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elt-conjugacy.md#function-conjugacyclasses-grppc)
- [`Classes(G): GrpPC → [ ]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elt-conjugacy.md#function-classes-grppc)
- [`ClassMap(G): GrpPC → Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elt-conjugacy.md#function-classmap-grppc)
- [`ClassRepresentative(G, x): GrpPC, GrpPCElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elt-conjugacy.md#function-classrepresentative-grppc-grppcelt)
- [`ClassRepresentative(G, i): GrpPC, RngIntElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elt-conjugacy.md#function-classrepresentative-grppc-rngintelt)
- [`ClassCentraliser(G, i): GrpPC, RngIntElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elt-conjugacy.md#function-classcentraliser-grppc-rngintelt)
- [`ClassCentralizer(G, i): GrpPC, RngIntElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elt-conjugacy.md#function-classcentralizer-grppc-rngintelt)
- [`IsConjugate(G, g, h): GrpPC, GrpPCElt, GrpPCElt → BoolElt, GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elt-conjugacy.md#function-isconjugate-grppc-grppcelt-grppcelt-2)
- [`NumberOfClasses(G): GrpPC → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elt-conjugacy.md#function-numberofclasses-grppc)
- [`Nclasses(G): GrpPC → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elt-conjugacy.md#function-nclasses-grppc)
- [`PowerMap(G): GrpPC → Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elt-conjugacy.md#function-powermap-grppc)
- [Example: Conjugacy Classes of SL(2, 3)](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/elt-conjugacy.md#example-ex-bdfb19)
- [Subgroups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md)
- [Definition of Subgroups by Generators](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#definition-of-subgroups-by-generators)
- [`sub: GrpPC, List → GrpPC, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#constructor-constructor-sub-grppc-list-grppc-map)
- [`ncl: GrpPC, List → GrpPC, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#constructor-constructor-ncl-grppc-list-grppc-map)
- [Example: Creating Subgroups by Generators](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#example-ex-9f724a)
- [Membership and Coercion](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#membership-and-coercion)
- [`g in G: GrpPCElt, GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#operation-op-in-grppcelt-grppc)
- [`g notin G: GrpPCElt, GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#operation-op-notin-grppcelt-grppc)
- [`G ! g: GrpPC, GrpPCElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#operation-op-grppc-grppcelt)
- [`H ! g: GrpPC, GrpPCElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#operation-op-grppc-grppcelt-2)
- [`K ! g: GrpPC, GrpPCElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#operation-op-grppc-grppcelt-3)
- [Example: Membership and Coercion in Subgroups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#example-ex-ac7047)
- [Inclusion and Equality](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#inclusion-and-equality)
- [`S subset G: { GrpPCElt}, GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#operation-op-subset-grppcelt-grppc)
- [`S notsubset G: { GrpPCElt}, GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#operation-operation-notsubset-grppcelt-grppc-boolelt)
- [`H subset G: GrpPC, GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#operation-op-subset-grppc-grppc)
- [`IsSubgroup(H,G): GrpPC, GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-issubgroup-grppc-grppc)
- [`H notsubset G: GrpPC, GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#operation-operation-notsubset-grppc-grppc-boolelt)
- [`G eq H: GrpPC, GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#operation-op-eq-grppc-grppc)
- [`G ne H: GrpPC, GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#operation-op-ne-grppc-grppc)
- [`InclusionMap(G, H): GrpPC, GrpPC → Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-inclusionmap-grppc-grppc)
- [Standard Subgroup Constructions](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#standard-subgroup-constructions)
- [`H ^ g: GrpPC, GrpPCElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#operation-op-pow-grppc-grppcelt)
- [`Conjugate(H, g): GrpPC, GrpPCElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-conjugate-grppc-grppcelt)
- [`H meet K: GrpPC, GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#operation-op-meet-grppc-grppc)
- [`H meet:= K: GrpPC, GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#operation-operation-meet-grppc-grppc-grppc)
- [`CommutatorSubgroup(G, H, K): GrpPC, GrpPC, GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-commutatorsubgroup-grppc-grppc-grppc)
- [`CommutatorSubgroup(H, K): GrpPC, GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-commutatorsubgroup-grppc-grppc)
- [`Centralizer(G, g): GrpPC, GrpPCElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-centralizer-grppc-grppcelt)
- [`Centraliser(G, g): GrpPC, GrpPCElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-centraliser-grppc-grppcelt)
- [`Centralizer(G, H): GrpPC, GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-centralizer-grppc-grppc)
- [`Centraliser(G, H): GrpPC, GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-centraliser-grppc-grppc)
- [`Core(G, H): GrpPC, GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-core-grppc-grppc)
- [`H ^ G: GrpPC, GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#operation-op-pow-grppc-grppc)
- [`NormalClosure(G, H): GrpPC, GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-normalclosure-grppc-grppc)
- [`Normalizer(G, H): GrpPC, GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-normalizer-grppc-grppc)
- [`Normaliser(G, H): GrpPC, GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-normaliser-grppc-grppc)
- [Example: Subgroup Constructions](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#example-ex-38016c)
- [Properties of Subgroups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#properties-of-subgroups)
- [`Index(G, H): GrpPC, GrpPC → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-index-grppc-grppc)
- [`FactoredIndex(G, H): GrpPC, GrpPC → []`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-factoredindex-grppc-grppc)
- [Predicates for Subgroups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#predicates-for-subgroups)
- [`IsCentral(G, H): GrpPC, GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-iscentral-grppc-grppc)
- [`IsConjugate(G, H, K): GrpPC, GrpPC, GrpPC → BoolElt, GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-isconjugate-grppc-grppc-grppc)
- [`IsMaximal(G, H): GrpPC, GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-ismaximal-grppc-grppc)
- [`IsNormal(G, H): GrpPC, GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-isnormal-grppc-grppc)
- [`IsSelfNormalizing(G, H): GrpPC, GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-isselfnormalizing-grppc-grppc)
- [`IsSubnormal(G, H): GrpPC, GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-issubnormal-grppc-grppc)
- [Example: Predicates for Subgroups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#example-ex-340cb9)
- [Hall $\pi$-Subgroups and Sylow Systems](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#hall-pi-subgroups-and-sylow-systems)
- [`ComplementBasis(G): GrpPC → [GrpPC]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-complementbasis-grppc)
- [`HallSubgroup(G, S): GrpPC, { RngIntElt} → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-hallsubgroup-grppc-rngintelt)
- [`HallSubgroup(G, S): GrpPC, RngIntElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-hallsubgroup-grppc-rngintelt-2)
- [`pCore(G, S): GrpPC, { RngIntElt} → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-pcore-grppc-rngintelt)
- [`pCore(G, S): GrpPC, RngIntElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-pcore-grppc-rngintelt-2)
- [`SylowBasis(G): GrpPC → [GrpPC]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-sylowbasis-grppc)
- [`SylowSubgroup(G, p): GrpPC, RngIntElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-sylowsubgroup-grppc-rngintelt)
- [`Sylow(G, p): GrpPC, RngIntElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-sylow-grppc-rngintelt)
- [`SystemNormalizer(G): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-systemnormalizer-grppc)
- [`SystemNormaliser(G): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-systemnormaliser-grppc)
- [Example: Hall Subgroups of a Wreath Product](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#example-ex-475f0f)
- [Conjugacy Classes of Subgroups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#conjugacy-classes-of-subgroups)
- [`SubgroupClasses(G): GrpPC → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-subgroupclasses-grppc)
- [`Subgroups(G): GrpPC → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-subgroups-grppc)
- [`AbelianSubgroups(G): GrpPC → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-abeliansubgroups-grppc)
- [`CyclicSubgroups(G): GrpPC → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-cyclicsubgroups-grppc)
- [`ElementaryAbelianSubgroups(G): GrpPC → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-elementaryabeliansubgroups-grppc)
- [`NilpotentSubgroups(G): GrpPC → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-nilpotentsubgroups-grppc)
- [`LowIndexSubgroups(G, n): GrpPC, RngIntElt → []`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-lowindexsubgroups-grppc-rngintelt)
- [`MaximalSubgroups(G): GrpPC → [GrpPC]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-maximalsubgroups-grppc)
- [`SubgroupLattice(G): GrpPC → SubGrpLat`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-subgrouplattice-grppc)
- [`BurnsideMatrix(G): GrpPC → AlgMatElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-burnsidematrix-grppc)
- [`TableOfMarks(G): GrpPC → AlgMatElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#function-tableofmarks-grppc)
- [`DisplayBurnsideMatrix(G): GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#procedure-displayburnsidematrix-grppc)
- [Example: Subgroup Classes](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/subgroups.md#example-ex-cf7628)
- [Quotient Groups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/quotient.md)
- [Construction of Quotient Groups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/quotient.md#construction-of-quotient-groups)
- [`quo: GrpPC, List → GrpPC, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/quotient.md#constructor-constructor-quo-grppc-list-grppc-map)
- [`G / N: GrpPC, GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/quotient.md#operation-op-div-grppc-grppc)
- [Example: Quotient Groups of a Pc-Group](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/quotient.md#example-ex-934992)
- [Abelian and $p$-Quotients](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/quotient.md#abelian-and-p-quotients)
- [`AbelianQuotient(G): GrpPC → GrpAb, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/quotient.md#function-abelianquotient-grppc)
- [`AbelianQuotientInvariants(G): GrpPC → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/quotient.md#function-abelianquotientinvariants-grppc)
- [`AQInvariants(G): GrpPC → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/quotient.md#function-aqinvariants-grppc)
- [`ElementaryAbelianQuotient(G, p): GrpPC, RngIntElt → GrpAb, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/quotient.md#function-elementaryabelianquotient-grppc-rngintelt)
- [`pQuotient(G, p, c : parameters ): GrpPC, RngIntElt, RngIntElt → GrpPC, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/quotient.md#function-pquotient-grppc-rngintelt-rngintelt)
- [Normal Subgroups and Subgroup Series](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md)
- [Characteristic Subgroups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#characteristic-subgroups)
- [`Centre(G): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-centre-grppc)
- [`Center(G): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-center-grppc)
- [`CommutatorSubgroup(G): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-commutatorsubgroup-grppc)
- [`DerivedSubgroup(G): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-derivedsubgroup-grppc)
- [`DerivedGroup(G): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-derivedgroup-grppc)
- [`FittingSubgroup(G): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-fittingsubgroup-grppc)
- [`FittingGroup(G): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-fittinggroup-grppc)
- [`FrattiniSubgroup(G): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-frattinisubgroup-grppc)
- [`PrefrattiniSubgroup(G): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-prefrattinisubgroup-grppc)
- [`FrattiniQuotientRank(G): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-frattiniquotientrank-grppc)
- [`Hypercentre(G): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-hypercentre-grppc)
- [`Hypercenter(G): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-hypercenter-grppc)
- [`MinimalNormalSubgroups(G): GrpPC → [GrpPC]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-minimalnormalsubgroups-grppc)
- [`pCore(G, S): GrpPC, { RngIntElt} → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-pcore-grppc-rngintelt-3)
- [`pCore(G, S): GrpPC, RngIntElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-pcore-grppc-rngintelt-4)
- [`Socle(G): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-socle-grppc)
- [Subgroup Series](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#subgroup-series)
- [`PrimaryAbelianBasis(G): GrpPC → [ GrpPCElt ], [ RngIntElt ]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-primaryabelianbasis-grppc)
- [`AbelianBasis(G): GrpPC → [ GrpPCElt ], [ RngIntElt ]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-abelianbasis-grppc)
- [`PrimaryAbelianInvariants(G): GrpPC → [RngIntElt]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-primaryabelianinvariants-grppc)
- [`AbelianInvariants(G): GrpPC → [RngIntElt]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-abelianinvariants-grppc)
- [`ChiefSeries(G): GrpPC → [GrpPC]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-chiefseries-grppc)
- [`CompositionSeries(G): GrpPC → [GrpPC]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-compositionseries-grppc)
- [`CompositionFactors(G): GrpPC → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-compositionfactors-grppc)
- [`CompositionSeries(G, i): GrpPC, RngIntElt → [GrpPC]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-compositionseries-grppc-rngintelt)
- [`DerivedSeries(G): GrpPC → [GrpPC]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-derivedseries-grppc)
- [`DerivedLength(G): GrpPC → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-derivedlength-grppc)
- [`ElementaryAbelianSeries(G): GrpPC → [GrpPC]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-elementaryabelianseries-grppc)
- [`ElementaryAbelianSeriesCanonical(G): GrpPC → [GrpPC]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-elementaryabelianseriescanonical-grppc)
- [`LowerCentralSeries(G): GrpPC → [GrpPC]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-lowercentralseries-grppc)
- [`NilpotencyClass(G): GrpPC → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-nilpotencyclass-grppc)
- [`pCentralSeries(G, p): GrpPC, RngIntElt → [GrpPC]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-pcentralseries-grppc-rngintelt)
- [`SubnormalSeries(G, H): GrpPC, GrpPC → [GrpPC]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-subnormalseries-grppc-grppc)
- [`UpperCentralSeries(G): GrpPC → [GrpPC]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-uppercentralseries-grppc)
- [Example: Elementary Abelian Series](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#example-ex-54e655)
- [Series for $p$-groups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#series-for-p-groups)
- [`Agemo(G, i): GrpPC, RngIntElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-agemo-grppc-rngintelt)
- [`Omega(G, i): GrpPC, RngIntElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-omega-grppc-rngintelt)
- [`JenningsSeries(G): GrpPC → [GrpPC]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-jenningsseries-grppc)
- [`pClass(G): GrpPC → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-pclass-grppc)
- [`pRanks(G): GrpPC → [ RngIntElt ]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-pranks-grppc)
- [Normal Subgroups and Complements](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#normal-subgroups-and-complements)
- [`NormalSubgroups(G): GrpPC → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-normalsubgroups-grppc)
- [`NormalLattice(G): GrpPC → SubGrpLat`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-normallattice-grppc)
- [`MinimalNormalSubgroup(G): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-minimalnormalsubgroup-grppc)
- [`MinimalNormalSubgroup(G, N): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-minimalnormalsubgroup-grppc-2)
- [`Complements(G, N): GrpPC, GrpPC → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-complements-grppc-grppc)
- [`NormalComplements(G, N): GrpPC, GrpPC → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-normalcomplements-grppc-grppc)
- [`NormalComplements(G, H, N): GrpPC, GrpPC, GrpPC → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#function-normalcomplements-grppc-grppc-grppc)
- [Example: Normal Complements](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/normal-series.md#example-ex-12efb9)
- [Cosets](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/cosets.md)
- [Coset Tables and Transversals](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/cosets.md#coset-tables-and-transversals)
- [`Transversal(G, H): GrpPC, GrpPC → {@ GrpPCElt @}, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/cosets.md#function-transversal-grppc-grppc)
- [`RightTransversal(G, H): GrpPC, GrpPC → {@ GrpPCElt @}, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/cosets.md#function-righttransversal-grppc-grppc)
- [`CosetTable(G, H): GrpPC, GrpPC → Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/cosets.md#function-cosettable-grppc-grppc)
- [`Transversal(G, H, K): GrpPC, GrpPC, GrpPC → {@ GrpPCElt @}, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/cosets.md#function-transversal-grppc-grppc-grppc)
- [`ShortCosets(p, H, G): GrpPCElt, GrpPC, GrpPC → [GrpPCElt]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/cosets.md#function-shortcosets-grppcelt-grppc-grppc)
- [Action on a Coset Space](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/cosets.md#action-on-a-coset-space)
- [`CosetAction(G, H): Grp, Grp → Hom(Grp), GrpPerm, GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/cosets.md#function-cosetaction-grp-grp)
- [`CosetImage(G, H): Grp, Grp → GrpPerm`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/cosets.md#function-cosetimage-grp-grp)
- [`CosetKernel(G, H): Grp, Grp → Grp`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/cosets.md#function-cosetkernel-grp-grp)
- [Automorphism Group](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md)
- [General Soluble Group](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#general-soluble-group)
- [Lifting Algorithm](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#lifting-algorithm)
- [`AutomorphismGroup(G): GrpPC → GrpAuto`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#function-automorphismgroup-grppc)
- [`HasAttribute(A, "GenWeights"): GrpAuto, MonStgElt → BoolElt, [ RngIntElt ]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#function-hasattribute-grpauto-monstgelt-genweights)
- [`HasAttribute(A, "WeightSubgroupOrders"): GrpAuto, MonStgElt → BoolElt, [ RngIntElt ]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#function-hasattribute-grpauto-monstgelt-weightsubgrouporders)
- [Example: Automorphism Group via Lifting](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#example-ex-29a2d6)
- [Lifting from the Automorphism Group of a Sylow $p$-subgroup](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#lifting-from-the-automorphism-group-of-a-sylow-p-subgroup)
- [`AutomorphismGroupSolubleGroup(G: parameters): GrpPC → GrpAuto`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#function-automorphismgroupsolublegroup-grppc)
- [`IsIsomorphicSolubleGroup(G, H: parameters): GrpPC, GrpPC → BoolElt, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#function-isisomorphicsolublegroup-grppc-grppc)
- [Example: Automorphisms of a Soluble Group](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#example-ex-249c9b)
- [$p$-group](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#p-group)
- [`AutomorphismGroup(G: parameters): GrpPC → GrpAuto`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#function-automorphismgroup-grppc-2)
- [Example: Automorphism Group of a p-Group](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#example-ex-f1bbe5)
- [`OrderAutomorphismGroupAbelianPGroup(A): SeqEnum → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#function-orderautomorphismgroupabelianpgroup-seqenum)
- [Example: Subgroups of an Abelian p-Group](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#example-ex-c99f0c)
- [Isomorphism and Standard Presentations](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#isomorphism-and-standard-presentations)
- [`StandardPresentation(G): GrpPC → GrpPC, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#function-standardpresentation-grppc)
- [`StandardPresentation(G: parameters): GrpPC → GrpAuto`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#function-standardpresentation-grppc-2)
- [`IsIdenticalPresentation(G, H): GrpPC, GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#function-isidenticalpresentation-grppc-grppc)
- [`IsIsomorphic(G, H): GrpPC, GrpPC → BoolElt, Map, GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#function-isisomorphic-grppc-grppc)
- [Example: Isomorphism of p-Quotients](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/automorphism-group.md#example-ex-75ee54)
- [Generating $p$-groups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/p-groups.md)
- [`GeneratepGroups(p, d, c : parameters): RngIntElt, RngIntElt, RngIntElt → [GrpPC], RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/p-groups.md#function-generatepgroups-rngintelt-rngintelt-rngintelt)
- [`Descendants(G : parameters): GrpPC → [GrpPC], RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/p-groups.md#function-descendants-grppc)
- [`Descendants(G, c : parameters): GrpPC, RngIntElt → [GrpPC], RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/p-groups.md#function-descendants-grppc-rngintelt)
- [Example: Descendants of a 2-Group](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/p-groups.md#example-ex-3d4202)
- [Example: 2-Generator Groups of Exponent 4](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/p-groups.md#example-ex-e130f7)
- [Example: 2-Generator 3-Groups of Abundance Zero](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/p-groups.md#example-ex-4efc58)
- [`ClassTwo(p, d : parameters): RngIntElt, RngIntElt → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/p-groups.md#function-classtwo-rngintelt-rngintelt)
- [`ClassTwo(p, d, Step : parameters): RngIntElt, RngIntElt, SeqEnum → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/p-groups.md#function-classtwo-rngintelt-rngintelt-seqenum)
- [`ClassTwo(p, d, s : parameters): RngIntElt, RngIntElt, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/p-groups.md#function-classtwo-rngintelt-rngintelt-rngintelt)
- [Example: Counting p-Class 2 Groups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/p-groups.md#example-ex-6ce143)
- [Representation Theory](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md)
- [`CharacterDegrees(G): GrpPC → [ Tup ]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-characterdegrees-grppc)
- [`CharacterDegrees(G, z, p): GrpPC, GrpPCElt, RngIntElt → [ Tup ]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-characterdegrees-grppc-grppcelt-rngintelt)
- [`CharacterDegrees(G): GrpFin → [ Tup ]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-characterdegrees-grpfin)
- [`CharacterDegreesPGroup(G): GrpFin → [ RngIntElt ]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-characterdegreespgroup-grpfin)
- [`CharacterTable(G: parameters): GrpPC → TabChtr`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-charactertable-grppc)
- [`CharacterTableConlon(G): GrpPC → [ AlgChtrElt ]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-charactertableconlon-grppc)
- [`GModule(G, M): GrpPC, AlgMat → ModAlg`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-gmodule-grppc-algmat)
- [`GModule(G, A): GrpPC, GrpPC → ModAlg, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-gmodule-grppc-grppc)
- [`GModule(G, A, B): GrpPC, GrpPC, GrpPC → ModAlg, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-gmodule-grppc-grppc-grppc)
- [`AbsolutelyIrreducibleRepresentationsSchur(G, k: parameters): GrpPC, Rng → List[Map]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-absolutelyirreduciblerepresentationsschur-grppc-rng)
- [`AbsolutelyIrreducibleModulesSchur(G, k: parameters): GrpPC, Rng → List[GModule]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-absolutelyirreduciblemodulesschur-grppc-rng)
- [`AbsolutelyIrreducibleRepresentationsSchur(G, k, i: parameters): GrpPC, Rng, RngIntElt → List[Map]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-absolutelyirreduciblerepresentationsschur-grppc-rng-rngintelt)
- [`AbsolutelyIrreducibleModulesSchur(G, k, i: parameters): GrpPC, Rng, RngIntElt → List[GModule]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-absolutelyirreduciblemodulesschur-grppc-rng-rngintelt)
- [`AbsolutelyIrreducibleRepresentationsSchur(G, k, L: parameters): GrpPC, Rng, List[Map] → List[Map]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-absolutelyirreduciblerepresentationsschur-grppc-rng-list-map)
- [`AbsolutelyIrreducibleModulesSchur(G, k, L: parameters): GrpPC, Rng, List[GModule] → List[GModule]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-absolutelyirreduciblemodulesschur-grppc-rng-list-gmodule)
- [`AbsolutelyIrreducibleRepresentationsSchur(G, k, L, i: parameters): GrpPC, Rng, List[Map], RngIntElt → List[Map]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-absolutelyirreduciblerepresentationsschur-grppc-rng-list-map-rngintelt)
- [`AbsolutelyIrreducibleModulesSchur(G, k, L, i: parameters): GrpPC, Rng, RngIntElt → List[GModule]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-absolutelyirreduciblemodulesschur-grppc-rng-rngintelt-2)
- [`IrreducibleRepresentationsSchur(G, k: parameters): GrpPC, Rng → List[Map]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-irreduciblerepresentationsschur-grppc-rng)
- [`IrreducibleModulesSchur(G, k: parameters): GrpPC, Rng → List[GModule]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-irreduciblemodulesschur-grppc-rng)
- [`IrreducibleRepresentationsSchur(G, k, i: parameters): GrpPC, Rng, RngIntElt → List[Map]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-irreduciblerepresentationsschur-grppc-rng-rngintelt)
- [`IrreducibleModulesSchur(G, k, i: parameters): GrpPC, Rng, RngIntElt → List[GModule]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-irreduciblemodulesschur-grppc-rng-rngintelt)
- [`IrreducibleRepresentationsSchur(G, k, L: parameters): GrpPC, Rng, List[Map] → List[Map]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-irreduciblerepresentationsschur-grppc-rng-list-map)
- [`IrreducibleModulesSchur(G, k, L: parameters): GrpPC, Rng, List[GModule] → List[GModule]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-irreduciblemodulesschur-grppc-rng-list-gmodule)
- [`IrreducibleRepresentationsSchur(G, k, L, i: parameters): GrpPC, Rng, List[Map], RngIntElt → List[Map]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-irreduciblerepresentationsschur-grppc-rng-list-map-rngintelt)
- [`IrreducibleModulesSchur(G, k, L, i: parameters): GrpPC, Rng, List[GModule], RngIntElt → List[GModule]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#function-irreduciblemodulesschur-grppc-rng-list-gmodule-rngintelt)
- [Example: Representations of the Dihedral Group of Order 20](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/character-representation.md#example-ex-ca921e)
- [Central Extensions](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/central-extensions.md)
- [`ExtGenerators(G, U): GrpPC, GrpPC → []`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/central-extensions.md#function-extgenerators-grppc-grppc)
- [`HomGenerators(G, U): GrpPC, GrpPC → []`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/central-extensions.md#function-homgenerators-grppc-grppc)
- [`ElementSequence(G): GrpPC → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/central-extensions.md#function-elementsequence-grppc)
- [`RepresentativeCocycles(G, U, Ext, Hom): GrpPC, GrpPC, [AlgMatElt], [AlgMatElt] → [AlgMatElt]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/central-extensions.md#function-representativecocycles-grppc-grppc-algmatelt-algmatelt)
- [`CentralExtension(G, U, A): GrpPC, GrpPC, AlgMatElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/central-extensions.md#function-centralextension-grppc-grppc-algmatelt)
- [`CentralExtensions(G, U, Q): GrpPC, GrpPC, [AlgMatElt] → [GrpPC]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/central-extensions.md#function-centralextensions-grppc-grppc-algmatelt)
- [`CentralExtensionProcess(G, U): GrpPC, GrpPC → Proc`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/central-extensions.md#function-centralextensionprocess-grppc-grppc)
- [`NextExtension(~P): Rec → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/central-extensions.md#function-nextextension-rec-ref)
- [`IsEmpty(P): Rec → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/central-extensions.md#function-isempty-rec)
- [Example: Central Extensions of a Dihedral Group](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/central-extensions.md#example-ex-b4d774)
- [Transfer Between Group Categories](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/transfer-functions.md)
- [Transfer to GrpPC](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/transfer-functions.md#transfer-to-grppc)
- [`PCGroup(G): GrpPerm → GrpPC, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/transfer-functions.md#function-pcgroup-grpperm)
- [`PCGroup(G): GrpMat → GrpPC, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/transfer-functions.md#function-pcgroup-grpmat)
- [`PCGroup(G): GrpFP → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/transfer-functions.md#function-pcgroup-grpfp)
- [`pQuotient(F, p, c : parameters ): GrpFP, RngIntElt, RngIntElt → GrpPC, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/transfer-functions.md#function-pquotient-grpfp-rngintelt-rngintelt)
- [`SolubleQuotient(G): Grp → GrpPC, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/transfer-functions.md#function-solublequotient-grp)
- [`SolvableQuotient(G): Grp → GrpPC, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/transfer-functions.md#function-solvablequotient-grp)
- [Example: Pc-Presentation of a Matrix Group](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/transfer-functions.md#example-ex-84bae2)
- [Transfer from GrpPC](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/transfer-functions.md#transfer-from-grppc)
- [`AbelianGroup(G): GrpPC → GrpAb, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/transfer-functions.md#function-abeliangroup-grppc)
- [`FPGroup(G): GrpPC → GrpFP, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/transfer-functions.md#function-fpgroup-grppc)
- [`GPCGroup(G): GrpPC → GrpGPC, Map`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/transfer-functions.md#function-gpcgroup-grppc)
- [Example: Pc-Group to Permutation Group](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/transfer-functions.md#example-ex-b68da2)
- [More About Presentations](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md)
- [Conditioned Presentations](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#conditioned-presentations)
- [Structure Operations](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#structure-operations)
- [`ConditionedGroup(G): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#function-conditionedgroup-grppc)
- [`IsConditioned(G): GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#function-isconditioned-grppc)
- [Element Operations](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#element-operations)
- [`LeadingTerm(x): GrpPCElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#function-leadingterm-grppcelt)
- [`LeadingGenerator(x): GrpPCElt → GrpPCElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#function-leadinggenerator-grppcelt)
- [`LeadingExponent(x): GrpPCElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#function-leadingexponent-grppcelt)
- [`Depth(x): GrpPCElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#function-depth-grppcelt)
- [`PCClass(x): GrpPCElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#function-pcclass-grppcelt)
- [`WeightClass(x): GrpPCElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#function-weightclass-grppcelt)
- [Special Presentations](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#special-presentations)
- [`SpecialPresentation(G): GrpPC → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#function-specialpresentation-grppc)
- [`SpecialWeights(G): GrpPC → [ ]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#function-specialweights-grppc)
- [`NilpotentLength(G): GrpPC → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#function-nilpotentlength-grppc)
- [`NilpotentBoundary(G,i): GrpPC, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#function-nilpotentboundary-grppc-rngintelt)
- [`MinorLength(G,i): GrpPC, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#function-minorlength-grppc-rngintelt)
- [`MinorBoundary(G,i,j): GrpPC, RngIntElt, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#function-minorboundary-grppc-rngintelt-rngintelt)
- [`LayerLength(G,i,j): GrpPC, RngIntElt, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#function-layerlength-grppc-rngintelt-rngintelt)
- [`LayerBoundary(G,i,j,k): GrpPC, RngIntElt, RngIntElt, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#function-layerboundary-grppc-rngintelt-rngintelt-rngintelt)
- [Example: User and Special Presentations](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#example-ex-4806c3)
- [CompactPresentation](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#compactpresentation)
- [`CompactPresentation(G): GrpPC → [RngIntElt]`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#function-compactpresentation-grppc)
- [`PCGroup(Q : parameters ): [RngIntElt] → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#function-pcgroup-rngintelt)
- [Example: Compact Presentation for a Library](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/more-presentations.md#example-ex-73c5b4)
- [Optimizing Magma Code](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/optimization.md)
- [PowerGroup](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/optimization.md#powergroup)
- [Example: Optimising with a Power Group](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/optimization.md#example-ex-952208)
- [$p$-Groups of Tame Genus](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md)
- [Verbose Printing](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#verbose-printing)
- [Example: Verbose Printing](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#example-ex-e49bb4)
- [Constructors](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#constructors)
- [`TGRandomGroup(q, n, g : parameters): RngIntElt, RngIntElt, RngIntElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#function-tgrandomgroup-rngintelt-rngintelt-rngintelt)
- [Example: Random Groups of Tame Genus](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#example-ex-7e07d7)
- [`RandomGenus2Group(q, d : parameters): RngIntElt, [RngIntElt] → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#function-randomgenus2group-rngintelt-rngintelt)
- [Example: Genus 2 Groups with Prescribed Blocks](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#example-ex-3b8b51)
- [`RandomGenus1Group(q, d, r : parameters): RngIntElt, RngIntElt, RngIntElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#function-randomgenus1group-rngintelt-rngintelt-rngintelt)
- [Example: Heisenberg Groups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#example-ex-3634bf)
- [`Genus2Group(f): RngUPolElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#function-genus2group-rngupolelt)
- [`Genus2Group(f): RngMPolElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#function-genus2group-rngmpolelt)
- [Example: Genus 2 Group from a Pfaffian](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#example-ex-ff5bc5)
- [Direct Indecomposability](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#direct-indecomposability)
- [`IsIndecomposable(G): GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#function-isindecomposable-grppc)
- [`IsIndecomposable(t): TenSpcElt → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#function-isindecomposable-tenspcelt)
- [Example: Decomposable Groups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#example-ex-3b99f7)
- [Example: Indecomposable Central Products](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#example-ex-f8f20b)
- [Genus](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#genus)
- [`Genus(G): GrpPC → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#function-genus-grppc)
- [`Genus(t): TenSpcElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#function-genus-tenspcelt)
- [Example: Genus of Small Groups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#example-ex-40dc90)
- [`IsTameGenusGroup(G): Group → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#function-istamegenusgroup-group)
- [`IsTameGenusTensor(t): TenSpcElt → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#function-istamegenustensor-tenspcelt)
- [Example: Group Not of Tame Genus](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#example-ex-da6133)
- [Example: Filtering Small Groups by Tame Genus](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#example-ex-063b44)
- [Isomorphism](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#isomorphism)
- [`TGIsIsomorphic(G, H : parameters): GrpPC, GrpPC → BoolElt`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#function-tgisisomorphic-grppc-grppc)
- [Example: Isomorphism Testing](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#example-ex-13bda5)
- [`TGIsPseudoIsometric(s, t : parameters): TenSpcElt, TenSpcElt → BoolElt, Hmtp`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#function-tgispseudoisometric-tenspcelt-tenspcelt)
- [Example: Pseudo-Isometric Tensors](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#example-ex-e03ee8)
- [Automorphism Groups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#automorphism-groups)
- [`TGAutomorphismGroup(G : parameters): GrpPC → GrpAuto`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#function-tgautomorphismgroup-grppc)
- [Example: Automorphisms of a Flat Indecomposable Group](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#example-ex-36d32b)
- [`TGPseudoIsometryGroup(t : parameters): TenSpcElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#function-tgpseudoisometrygroup-tenspcelt)
- [Example: Tensors over an Extension Field](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#example-ex-35a1af)
- [Canonical Labelling](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#canonical-labelling)
- [`TGSignature(G): GrpPC → List`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#function-tgsignature-grppc)
- [`TGSignature(t): TenSpcElt → List`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#function-tgsignature-tenspcelt)
- [Example: Canonical Labels with Many Blocks](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#example-ex-bbc04e)
- [Example: Tame Genus Signatures of Small Groups](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/tame.md#example-ex-15bce1)
- [Bibliography](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/bibliography.md)
### Introduction
Any finite soluble group has a subnormal series with cyclic factors. Such a series gives rise to various polycyclic presentations. These polycyclic presentations are useful because the word problem in such presentations can be solved in an algorithmic fashion. In Magma, we use the specific form called a *power-conjugate presentation (pc-presentation)*, which is described below. The Magma category of groups represented by a power-conjugate presentation (pc-groups for short) is called `GrpPC`.
This chapter describes how to use polycyclic presentations to compute with $p$-groups and other finite soluble groups in Magma. While most functions apply to any soluble group, a small number of functions specific to $p$-groups are identified in the text.
Over the past two decades a considerable body of efficient algorithms has been developed for computing with soluble groups defined in terms of pc-presentations. It is recommended that the `GrpPC` representation of a soluble group be used whenever intensive calculation with that group is necessary.
#### Power-Conjugate Presentations
Let $G$ be a finite soluble group. A presentation for $G$ of the form
$$
< a_1, \ldots,a_n\ |\ a_j ^{p_j}= w_{jj}, \quad 1\leq j \leq n,
\quad a_j ^{a_i}= w_{ij},\quad 1 \leq i < j\leq n >
$$
where
**(i)**
$p_j$ is the least prime such that $a_j^{p_j} \in < a_{j+1}, \ldots, a_n>$ for $j < n$, and $a_j^{p_j}$ is the identity for $j = n$, and
**(ii)**
$w_{ij}$ is a word in the generators $a_{i+1}, \ldots, a_n$,
will be called a *power-conjugate presentation (pc-presentation)* for $G$. The generators of $G$ corresponding to $a_1, \ldots, a_n$ in this presentation are known as a *power-conjugate generating sequence (pc-generators)* for $G$.
It is easy to show that every finite soluble group possesses a pc-presentation. If such a presentation satisfies a certain additional condition (the *consistency condition*) then every element $a$ of $G$ can be written uniquely in the *normal form*
$$
a_1^{\alpha_1}\ldots a_n^{\alpha_n}, 0 \leq \alpha_i < p_i
\quad\hbox{\rm for }
i = 1, \ldots, n.
$$
Given such a pc-presentation for $G$ there exists an algorithm (the *collection algorithm*), which given an arbitrary word in the pc-generators $a_1, \ldots, a_n$, will determine the corresponding normal word. In particular, collection can be used to compute the normal word which is equal to the product of two given normal words, thus implementing the group multiplication.
### Creation of a Group
A user can create a `GrpPC` representation of a finite soluble group in a variety of ways. There are several built-in construction functions for creating standard examples such as cyclic or dihedral groups. For greater flexibility, it is possible to define a group directly from a power-commutator presentation. One can also build new groups out of old groups using standard constructions such as direct product. Finally, there are several conversion functions which will automatically compute a pc-presentation for an existing soluble group in some other category (such as permutation group or matrix group). We will start with the first two styles of construction and describe the remaining two in later sections.
In each case, regardless of how the group was originally defined, Magma will store the group internally as a pc-presentation and will display the pc-presentation whenever the group is printed. Normally when printing a pc-presentation, trivial conjugate relations are omitted. In the case of a $p$-group, then trivial power relations (those indicating that a generator has order $p$) are also omitted. The one exception to this policy is in the case of elementary abelian $p$-groups (which would have no relations displayed under the above policies). In the elementary abelian case, Magma will display the power relations, even though they are trivial.
#### Construction Functions
The simplest method of producing a pc-presentation for a group is to use one of the built-in construction functions. By specifying the category `GrpPC` as the first parameter of each function, we produce the desired representation.
It is also possible to obtain a pc-presentation for many small soluble groups by using the function [`SmallGroup`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-grpdata-smallgroup) described in Chapter [Databases of Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/index-databases-of-groups.md#chapgrpdata).
##### `CyclicGroup(GrpPC, n): Cat, RngIntElt -> GrpPC`
The cyclic group of order $n$ as a pc-group.
##### `AbelianGroup(GrpPC, Q): Cat, [RngIntElt] -> GrpPC`
Construct the abelian group defined by the sequence $Q = [n_1,\ldots,n_r]$ of positive integers as a pc-group. The function returns the abelian group which is the direct product of the cyclic groups $C_{n_1} \times C_{n_2} \times \cdots \times C_{n_r}$.
##### `DihedralGroup(GrpPC, n): Cat, RngIntElt -> GrpPC`
The dihedral group of order $2*n$ as a pc-group.
##### `ExtraSpecialGroup(GrpPC, p, n : parameters): Cat, RngIntElt, RngIntElt -> GrpPC`
```magma
Type: MonStgElt Default: "+"
```
Given a small prime $p$ and a small positive integer $n$, construct an extra-special group $G$ of order $p^{2n+1}$ in the category `GrpPC`. The isomorphism type of $G$ may be selected using the parameter `Type`.
Possible values for this parameter are “$+$” (default) and “$-$“.
If `Type` is set to “$+$”, the function returns, for $p = 2$, the central product of $n$ copies of the dihedral group of order 8, and for $p > 2$ it returns the unique extra-special group of order $p^{2n+1}$ and exponent $p$.
If `Type` is set to “$-$”, the function returns for $p = 2$ the central product of a quaternion group of order 8 and $n-1$ copies of the dihedral group of order 8, and for $p > 2$ it returns the unique extra-special group of order $p^{2n+1}$ and exponent $p^2$.
##### `Example: Pc-Representation of a Cyclic Group (ex-a851f0)`
A pc-representation for the cyclic group $C_{12}$ can be computed as follows.
```magma
> G := CyclicGroup(GrpPC, 12);
```
We can then check various properties of $G$.
```magma
> Order(G);
12
> IsAbelian(G);
true
> IsSimple(G);
false
```
If we simply print $G$, we will see the presentation which Magma has generated for this group.
```magma
> G;
GrpPC : G of order 12 = 2^2 * 3
PC-Relations:
G.1^2 = G.2,
G.2^2 = G.3,
G.3^3 = Id(G)
```
Or, we could build a slightly different group.
```magma
> H := AbelianGroup(GrpPC, [2,2,3]);
> Order(H);
12
> IsCyclic(H);
false
```
#### Definition by Presentation
While the standard construction functions are convenient, most groups cannot be defined in that way. Complete flexibility in defining a soluble group can be obtained by directly specifying the group’s pc-presentation.
One uses a power-conjugate presentation to define a soluble group by means of the `PolycyclicGroup` constructor, or the `quo` constructor for finitely presented groups.
##### `PolycyclicGroup< x₁, ..., xₙ | R : parameters >: List(Identifiers), List(GrpFPRel) -> GrpPC, Map`
```magma
Check : BoolElt Default: true
ExponentLimit: RngIntElt Default: 20
Class : MonStgElt Default:
```
Construct the soluble group $G$ defined by the power-conjugate presentation $<~x_1,~\ldots,~x_n~|~R~>$.
The construct $x_1, \ldots, x_n$ defines names for the generators of $G$ that are local to the constructor, i.e. they are used when writing down the relations to the right of the bar. However, no assignment of *values* to these variables is made. If the user wants to refer to the generators by these (or other) names, then the *generators assignment* construct must be used on the left hand side of an assignment statement.
The construct $R$ denotes a list of pc-relations. Thus, an element of $R$ must be one of:
**(a)**
A *power relation* $a_j^{p_j} = w_{jj}$, $1 \leq j \leq n$, where $w_{jj}$ is $1$ or a word in generators $a_{j+1}, \ldots,a_n$ for $j < n$, and $w_{jj} = 1$ for $j = n$, and $p_j$ a prime.
**(b)**
A *conjugate relation* $a_j^{a_i} = w_{ij}$, $1 \leq i < j \leq n$, where $w_{ij}$ is a word in the generators $a_{i+1}, \ldots, a_n$.
**(c)**
A *power* $a_j^{p_j}$, $1 \leq j \leq n$ and $p_j$ a prime, which is treated as the *power relation* $a_j^{p_j} = Id(F)$.
**(d)**
A set of (a) – (c).
**(e)**
A sequence of (a) – (c).
Note the following points:
**(i)**
A power relation must be present for each generator $a_i$, $i = 1, \ldots, n$;
**(ii)**
Conjugate relations involving commuting generators (i.e. of the form $y^x=y$) may be omitted;
**(iii)**
The words $w_{ij}$ must be in normal form.
In addition, one can alternatively specify a power-commutator presentation using commutator relations rather than conjugate relations.
**(b’)**
A *commutator relation* $(a_j, a_i) = w_{ij}$, $1 \leq i < j \leq n$, where $w_{ij}$ is a word in the generators $a_{i+1}, \ldots, a_n$.
However, commutators and conjugates cannot be mixed in a single presentation.
A map $f$ from the free group of rank $n$ to $G$ is returned as well.
The parameters `Check` and `ExponentLimit` may be used. `Check` indicates whether or not the presentation is checked for consistency. Setting `Check` to `false` will reduce the overheads incurred in constructing the group, but should only be done when the user is sure the given presentation is consistent.
`ExponentLimit` determines the amount of space that will be used by the group to speed calculations. Given `ExponentLimit := e`, the group will precompute and store normal words for appropriate products $a^i * b^j$ where $a$ and $b$ are generators and $i$ and $j$ are in the range 1 to $e$.
If the construction of an object in the category `GrpPC` fails because $R$ is not a valid power-conjugate presentation, an attempt is made to construct a group in the category [`GrpGPC`](https://docs.magma-maths.org/FinitelyPresentedGroups/PolycyclicGroups/index-polycyclic-groups.md#chapgrpgpc) (cf. Chapter [Polycyclic Groups](https://docs.magma-maths.org/FinitelyPresentedGroups/PolycyclicGroups/index-polycyclic-groups.md#chapgrpgpc)). This feature can be turned off by setting the parameter `Class` to `"GrpPC"`; an invalid power-conjugate presentation then causes a runtime error. Since, by default, the constructor always returns a group in the category `GrpPC` if possible, this is the only effect of setting the parameter `Class` to `"GrpPC"`.
##### `quo< GrpPC : F | R : parameters >: GrpFP, List(GrpFPRel) -> GrpPC, Map`
```magma
Check : BoolElt Default: true
ExponentLimit: RngIntElt Default: 20
```
Given a free group $F$ of rank $n$ with generating set $X$, and a collection $R$ of pc-relations on $X$, construct the soluble group $G$ defined by the power-conjugate presentation $< X | R >$.
The construct $R$ denotes a list of pc-relations. The syntax and semantics for the relations clause is identical to that appearing in the `PolycyclicGroup`-construct.
This constructor returns a pc-group because the category `GrpPC` is stated. If no category were stated, it would return an fp-group. The parameters `Check` and `ExponentLimit` may be used as described in the `PolycyclicGroup`-construct. The natural homomorphism, $F \rightarrow G$, is also returned.
##### `Example: Group of Order 80 from a Presentation (ex-a8ae01)`
Consider the group of order 80 defined by the presentation
$$
\begin{aligned}< a, b, c, d, e\ |\ &a^2 = c, b^2, c^2 = e, d^5, e^2, b^a = b*e, c^a = c, c^b = c, \\
&d^a = d^2, d^b = d, d^c = d^4, e^a = e, e^b = e, e^c = e, e^d = e >.\end{aligned}
$$
Giving the relations in the form of a list, this presentation would be specified as follows:
```magma
> G := PolycyclicGroup \indent\indent\indent a^2 = c, b^2, c^2 = e, d^5, e^2,
> \indent\indent\indent b^a = b*e, d^a = d^2, d^c = d^4 >;
```
Starting from a free group and giving the relations in the form of a set of relations, this presentation would be specified as follows:
```magma
> F := FreeGroup(5);
> rels := { a^2 = c, b^2 = Id(F), c^2 = e, d^5 = Id(F), e^2 = Id(F),
> \indent b^a = b*e, d^a = d^2, d^c = d^4 };
> G := quo< GrpPC : F | rels >;
```
Notice that here we have redefined the variables $a,\ldots ,e$ to be the pc-generators in $G$. Thus, when $G$ is printed, Magma displays the following presentation:
```magma
> G;
GrpPC : G of order 80 = 2^4 * 5
PC-Relations:
a^2 = c,
b^2 = Id(G),
c^2 = e,
d^5 = Id(G),
e^2 = Id(G),
b^a = b * e,
d^a = d^2,
d^c = d^4
> Order(G);
80
> IsAbelian(G);
false
```
#### Possibly Inconsistent Presentations
The `PolycyclicGroup` and `quo` constructors accept a parameter `Check` which enables the user to suppress the automatic consistency checking for input presentations. This is primarily intended to be used when it is certain that the input presentation is consistent, in order to save time. For instance, the presentation may have been generated from some other reliable program, or even from an earlier Magma session. This parameter should be used with care, since all of the Magma functions assume that every `GrpPC` group is consistent. The user will encounter numerous bizarre results if an attempt is made to compute with an inconsistent presentation.
On occasion, a user may wish to “try out” a series of pc-presentations, some of which may not be consistent. The `Check` parameter can be used, along with the function `IsConsistent`, to test a presentation for consistency.
##### `IsConsistent(G): GrpPC -> BoolElt`
Returns `true` if $G$ has a consistent presentation, `false` otherwise.
##### `Example: Checking Consistency of Presentations (ex-a62513)`
The following example demonstrates generating a family of presentations, and then checking consistency. Of course, it is easy to predict the outcome in this simple example.
```magma
> F := FreeGroup(2);
> for p in [n: n in [3..10] | IsPrime(n)] do
> r := [F.1^3=Id(F), F.2^p=Id(F), F.2^F.1=F.2^2];
> G := quo;
> if IsConsistent(G) then
> print "For p=",p," the group is consistent.";
> else
> print "For p=",p," the group is inconsistent.";
> end if;
> end for;
For p= 3 the group is inconsistent.
For p= 5 the group is inconsistent.
For p= 7 the group is consistent.
```
### Basic Group Properties
#### Infrastructure
The functions described here provide access to basic information stored for a pc-group $G$.
##### `G . i: GrpPC, RngIntElt -> GrpPCElt`
The $i$-th pc-generator for $G$. A negative subscript indicates that the inverse of the generator is to be created. $G.0$ is `Identity(G)`.
##### `Generators(G): GrpPC -> SetEnum`
A set containing the defining generators for $G$. If $G$ is a $p$-group, this is guaranteed to be a minimal set of generators. For non-$p$-groups, this will be the set of pc-generators.
##### `NumberOfGenerators(G): GrpPC -> RngIntElt`
##### `Ngens(G): GrpPC -> RngIntElt`
The number of defining generators for $G$.
##### `PCGenerators(G): GrpPC -> SetIndx`
An indexed set containing the pc-generators for $G$.
##### `NumberOfPCGenerators(G): GrpPC -> RngIntElt`
##### `NPCGenerators(G): GrpPC -> RngIntElt`
##### `NPCgens(G): GrpPC -> RngIntElt`
The number of pc-generators for $G$.
##### `PCPrimes(G): GrpPC -> [RngIntElt]`
A sequence [$p_1,\ldots,p_n$] containing the primes associated with the pc-generators of $G$. The $i$-th term of the sequence contains the prime associated with generator $a_i$ of $G$ for $i = 1,\ldots,n$.
#### Numerical Invariants
Magma has built-in functions to compute the order and exponent of a group.
##### `Order(G): GrpPC -> RngIntElt`
##### `# G: GrpPC -> RngIntElt`
The order of the group $G$, returned as an ordinary integer.
##### `FactoredOrder(G): GrpPC -> []`
The factored order of the group $G$.
##### `Exponent(G): GrpPC -> RngIntElt`
The exponent of the group $G$.
#### Predicates
Magma has built-in functions to check standard group properties.
##### `IsAbelian(G): GrpPC -> BoolElt`
Returns `true` if the group $G$ is abelian, `false` otherwise.
##### `IsCyclic(G): GrpPC -> BoolElt`
Returns `true` if the group $G$ is cyclic, `false` otherwise.
##### `IsElementaryAbelian(G): GrpPC -> BoolElt`
Returns `true` if the group $G$ is elementary abelian, `false` otherwise.
##### `IsNilpotent(G): GrpPC -> BoolElt`
Returns `true` if the group $G$ is nilpotent, `false` otherwise.
##### `IsPerfect(G): GrpPC -> BoolElt`
Returns `true` if the group $G$ is perfect, `false` otherwise. A soluble group $G$ is perfect only if it is trivial.
##### `IsSimple(G): GrpPC -> BoolElt`
Returns `true` if the group $G$ is simple, `false` otherwise.
##### `IsSoluble(G): GrpPC -> BoolElt`
##### `IsSolvable(G): GrpPC -> BoolElt`
Returns `true` if the group $G$ is soluble, `false` otherwise. It always returns the value `true` for a pc-group.
##### `IsTrivial(G): GrpPC -> BoolElt`
Returns `true` if the group $G$ has order 1, `false` otherwise.
##### `IsSpecial(G): GrpPC -> BoolElt`
Given a $p$-group $G$, return `true` if $G$ is special, `false` otherwise.
##### `IsExtraSpecial(G): GrpPC -> BoolElt`
Given a $p$-group $G$, return `true` if $G$ is extra-special, `false` otherwise.
##### `Example: Basic Properties of Pc-Groups (ex-e86fe2)`
We use a presentation to define an extraspecial 3-group of exponent 9.
```magma
> E := PolycyclicGroup z^3,b1^a1=b1*z,b2^a2=b2*z>;
```
The sequence of base, exponent pairs from `FactoredOrder` shows us that the group has order $3^5$.
```magma
> FactoredOrder(E);
[ <3, 5> ]
> Exponent(E);
9
```
As well as with the `Order` function, one can get the size of a group by using the `#` shorthand.
```magma
> D3 := DihedralGroup(GrpPC, 3);
> #D3;
6
> IsNilpotent(D3);
false
```
### Homomorphisms
Arbitrary homomorphisms can be defined between pc-groups by using the `hom<>` constructor. For pc-groups, this constructor has features not generally available for user-defined homomorphisms. In addition to defining the map by giving images for the pc-generators, a homomorphism can be defined by giving images for any generating set of the domain. Magma will verify that the specified images define a homomorphism and will compute the kernel and inverse images for the defined map. Note that the value returned for an inverse image of an element is simply one element from the preimage, not the complete coset.
#### `hom< G -> H | L >: GrpPC, GrpPC, List -> Map`
```magma
Check: BoolElt Default: true
```
Construct a homomorphism $\phi:G \rightarrow H$ defined by the images specified by the list $L$.
The list $L$ must be one of the following:
**(a)**
a list, set, or sequence of 2-tuples $$ (order not important);
**(b)**
a list, set, or sequence of arrow pairs $g_i -> h_i$ (order not important);
**(c)**
a list or sequence of images $h_1,\dots,h_n$ (order is important).
The elements $g_i$ and $h_i$ must be elements of $G$ and $H$, respectively, in each case. For the cases (a) and (b), the elements $g_i$ must generate $G$ and the homomorphism will satisfy $\phi(g_i) = h_i$. For case (c), $n$ must be the number of pc-generators of $G$ and the $g_i$ are implicitly defined to be the pc-generators. However, if $G$ is a $p$-group which has $p$-Quotient definitions set (see [`HaspQuotientDefinitions`](https://docs.magma-maths.org/FinitelyPresentedGroups/FPGroups/quotient.md#function-haspquotientdefinitions)), then $n$ can be the number of generators of $G$ (the result of `Ngens(G)`) and the $g_i$ are implicitly defined to be the first $n$ pc-generators.
The parameter `Check` can be set to `false` in order to turn off the check that the map defined is a homomorphism. This should only be done when one is certain that the map is a homomorphism, since later results will most likely be incorrect if it is not.
#### `IsHomomorphism(G, H, L): GrpPC, GrpPC, SeqEnum -> BoolElt, Map`
#### `IsHomomorphism(G, H, L): GrpPC, GrpPC, SetEnum[Tup] -> BoolElt, Map`
This is a conditional form of the `hom`-constructor. The argument $L$ must be a set or sequence of pairs (as in case (a) of the `hom`-constructor), or a sequence of images in $H$ for the pc-generators of $G$ (as in case (c) of the `hom`-constructor). If the specified images define a homomorphism, the value true and the resulting map are returned. Otherwise, `false` is returned.
#### `IdentityHomomorphism(G): GrpPC -> Map`
The identity map from $G$ to $G$.
#### `Kernel(f): Map -> GrpPC`
Given a homomorphism $f$ from one pc-group to another, return the kernel of $f$. This will be a pc-group which is a subgroup of the domain of $f$.
#### `Homomorphisms(G, H): GrpPC, GrpPC -> SeqEnum`
Given finite *abelian* groups $G$ and $H$, return a sequence containing all elements of ${\rm Hom}(G, H)$. The elements are returned as actual (Magma map type) homomorphisms. Note that this function simply uses `Hom`, transferring each element of the returned group to the actual Magma map type homomorphism.
#### `Example: Homomorphisms Between Pc-Groups (ex-d63f2e)`
Let $G$ be a pc-representation of the symmetric group $S_4$, and $N$ be $O_2(G)$.
```magma
> G := PCGroup(Sym(4));
> G;
GrpPC : G of order 24 = 2^3 * 3
PC-Relations:
G.1^2 = Id(G),
G.2^3 = Id(G),
G.3^2 = Id(G),
G.4^2 = Id(G),
G.2^G.1 = G.2^2,
G.3^G.1 = G.3 * G.4,
G.3^G.2 = G.4,
G.4^G.2 = G.3 * G.4
> N := pCore(G,2);
> Order(N);
4
```
Let us define $H$ to be a complement of $N$ in $G$.
```magma
> H := sub;
> Order(H);
6
> H meet N;
GrpPC of order 1
PC-Relations:
```
We now wish to define the projection homomorphism from $G$ to $H$. This will map each element of $N$ to the identity and each element of $H$ to itself. We can define the map directly using these properties.
```magma
> pairs := [];
> for n in Generators(N) do
> pairs cat:= [];
> end for;
> for h in Generators(H) do
> pairs cat:= [];
> end for;
> proj := hom H|pairs>;
> proj;
Mapping from: GrpPC: G to GrpPC: H
> proj(G.1);
H.1
> proj(N);
GrpPC of order 1
PC-Relations:
```
We can also compute inverse images and can verify that $N$ is the kernel of the map. Note that the preimage of a single element is just one element from the preimage, not the complete coset. Of course, one can use the kernel to compute the full coset if desired.
```magma
> y := (H.1)@@proj;
> y;
G.1
> Kernel(proj) eq N;
true
> {y*k: k in Kernel(proj)};
{ G.1 * G.3 * G.4, G.1 * G.4, G.1, G.1 * G.3 }
```
### New Groups from Existing
#### `DirectProduct(G, H): GrpPC, GrpPC -> GrpPC, [Map], [Map]`
The direct product $K$ of the pc-groups $G$ and $H$. The second argument returned is a sequence containing the inclusion maps $I_G\colon G \rightarrow K$ and $I_H\colon H \rightarrow K$. The third argument returned is a sequence containing the projection maps $P_G\colon K \rightarrow G$ and $P_H\colon K \rightarrow H$. Furthermore, the (user-) presentation of $K$ is arranged so that the first pc-generators correspond to those of $G$ and the remaining generators correspond to those of $H$.
#### `DirectProduct(Q): [GrpPC] -> GrpPC, [ Map ], [ Map ]`
The direct product of pc-groups in the non-empty sequence $Q$, and the inclusion and projection maps.
#### `Extension(G, H, f): GrpPC, GrpPC, [Map] -> GrpPC`
The split extension $K$ of the pc-group $G$ by the pc-group $H$, where the action of $H$ on $G$ is given by the homomorphism $\phi: H \rightarrow {\operatorname{Aut}}(G)$ specified by $f$. The extension $K$ will have a normal subgroup $G\mathord{\sim}$ isomorphic to $G$, while the quotient group $K/G\mathord{\sim}$ is isomorphic to $H$.
The homomorphism $\phi$ is given by the sequence of maps $f$. Suppose that the pc-generators for $H$ are $h_1, \ldots, h_s$. The $i$-th entry of $f$ defines the action of $h_i$ on $G$. That is, $f[i](x) = h_i^{-1}\cdot x\cdot h_i$, for $x \in G$.
#### `Extension(M, H): ModGrp, GrpPC -> GrpPC`
The split extension $K$ of the $G$-module $M$ by the pc-group $H$. We use the action of $H$ on $M$ to define the action of $H$ on an elementary abelian $p$-group of order $p^d$ where $M$ is a $d$-dimensional module over $GF(p)$, $p$ prime.
#### `Extension(G, H, f, t): GrpPC, GrpPC, [Map], [GrpPCElt] -> GrpPC`
#### `Extension(G, H, f, t): GrpPC, GrpPC, [Map], {Tup} -> GrpPC`
The non-split extension $K$ of the pc-group $G$ by the pc-group $H$, where the action of $H$ on $G$ is given by the homomorphism $\phi: H \rightarrow {\operatorname{Aut}}(G)$ and the tails for $H$ are given as the set of tuples $t$. The extension $K$ will have a normal subgroup $G\mathord{\sim}$ isomorphic to $G$, while the quotient group $K/G\mathord{\sim}$ is isomorphic to $H$.
The homomorphism $\phi$ is given by the sequence of maps $f$. Suppose that the pc-generators for $H$ are $h_1, \ldots, h_s$. The $i$-th entry of $f$ defines the action of $h_i$ on $G$. That is, $f[i](x) = h_i^{-1}\cdot x\cdot h_i$, for $x \in G$.
The specification of $t$ involves giving the relations $h_j^{-1}h_ih_j$ $= w_{ij}$, where $w_{ij}$ is a word in $K$ for $1 \le j < i \le s$. For $i = j$, we need the relation ${h_i}^{p_i} = w_{ii}$, where $w_{ii}$ is a word in $K$ for $1 \le i \le s$. Each $w_{ij}$ is the RHS of the relation from $H$ with the tail $x_{ij}$. The tails are given by the sequence $t$ in the order $t = [x_{11}, x_{21}, x_{22}, x_{31}, \ldots , x_{ss} ]$. Alternatively, $t$ can be given as a set of tuples $< i, j, x_{ij} >$ for non-trivial $x_{ij}$.
Note that if $x_{ij} =$`Id(G)`, for $1\leq i\leq s$ and $1\leq j\leq i$, then $K$ will just be the split extension of $G$ and $H$.
#### `Extension(M, H, t): ModGrp, GrpPC, [ModGrpElt] -> GrpPC`
The non-split extension $K$ of the $G$-module $M$ by the pc-group $H$. We use the action of $H$ on $M$ to define the action of $H$ on an elementary abelian $p$-group of order $p^d$ where $M$ is a $d$-dimensional module over $GF(p)$, $p$ prime.
The specification of $t$ is similar to that for $t$ in the preceding description.
#### `IsExtension(G, H, f): GrpPC, GrpPC, [Map] -> BoolElt, GrpPC`
#### `IsExtension(M, H): ModGrp, GrpPC -> BoolElt, GrpPC`
#### `IsExtension(G, H, f, t): GrpPC, GrpPC, [Map], [GrpPCElt] -> BoolElt, GrpPC`
#### `IsExtension(G, H, f, t): GrpPC, GrpPC, [Map], {Tup} -> BoolElt, GrpPC`
#### `IsExtension(M, H, t): ModGrp, GrpPC, [ModGrpElt] -> BoolElt, GrpPC`
For each `Extension` variation, there is a corresponding function `IsExtension` which attempts to construct the specified group and returns a boolean value indicating whether or not the construction succeeded. If the construction succeeds, the extension group is also returned.
The `Extension` functions will generate a runtime error if the specified construction is not legal. The `IsExtension` function allows the user to detect this error condition and continue.
#### `WreathProduct(G, H): GrpPC, GrpPC -> GrpPC`
The wreath product of the pc-groups $G$ and $H$, where the regular permutation representation of $H$ is used to define the action.
#### `WreathProduct(G, H, f): GrpPC, GrpPC, Map -> GrpPC`
#### `WreathProduct(G, H, f): GrpPC, GrpPC, [GrpPermElt] -> GrpPC`
The wreath product of the pc-groups $G$ and $H$ where the action of $H$ is given by $f$, which may be either a homomorphism from $H$ into a permutation group $P$ or a sequence of permutations defining a homomorphism from $H$ into $P$. If $f$ is a sequence, the homomorphism $\phi: H \rightarrow P$ is defined by $H.i \rightarrow f[i]$ for $i = 1, \ldots, s$.
#### `Example: Extensions of an Elementary Abelian Group (ex-73458c)`
To demonstrate some of the versions of `Extension` we first build a split extension of a cyclic group of order 4 acting on an elementary abelian group of order 9.
```magma
> C4 := CyclicGroup(GrpPC,4);
> E9 := AbelianGroup(GrpPC,[3,3]);
> f1 := homE9|[E9.1*E9.2^2, E9.1^2*E9.2^2]>;
> f2 := homE9|[E9.1^2,E9.2^2]>;
> G := Extension(E9,C4,[f1,f2]);
> G;
GrpPC : G of order 36 = 2^2 * 3^2
PC-Relations:
G.1^2 = G.2,
G.2^2 = Id(G),
G.3^3 = Id(G),
G.4^3 = Id(G),
G.3^G.1 = G.3 * G.4^2,
G.3^G.2 = G.3^2,
G.4^G.1 = G.3^2 * G.4^2,
G.4^G.2 = G.4^2
```
Then, we define a module for this group and use it to build a nonsplit extension.
```magma
> MR := MatrixRing(GF(3),2);
> m1 := MR![1,1,1,2];
> m2 := MR![2,0,0,2];
> V := GModule(G,[m1,m2,Id(MR),Id(MR)]);
> IsIrreducible(V);
true
> v0 := V!0;
> tails := [v0,v0,v0,v0,V![1,0],V![2,0],V![1,2],V![0,2],v0,V![0,1]];
> H := Extension(V,G,tails);
> H;
GrpPC : H of order 324 = 2^2 * 3^4
PC-Relations:
H.1^2 = H.2,
H.2^2 = Id(H),
H.3^3 = H.5^2,
H.4^3 = H.6,
H.5^3 = Id(H),
H.6^3 = Id(H),
H.3^H.1 = H.3 * H.4^2,
H.3^H.2 = H.3^2 * H.5,
H.4^H.1 = H.3^2 * H.4^2 * H.5 * H.6^2,
H.4^H.2 = H.4^2 * H.6^2,
H.5^H.1 = H.5 * H.6,
H.5^H.2 = H.5^2,
H.6^H.1 = H.5 * H.6^2,
H.6^H.2 = H.6^2
```
Notice that the relations of $H$ involving the first four generators are those of $G$ with the specified tails appended. We are then ready to compute various properties of $H$.
```magma
> [N`order:N in NormalSubgroups(H)];
[ 1, 9, 81, 162, 324 ]
```
#### `Example: Cossey-Hawkes Conjugacy Class Sizes (ex-9a45eb)`
In this example we verify an example of Cossey and Hawkes in [[CH00](https://docs.magma-maths.org/references.md#cite-ch-classes)]. The paper shows that the largest size of a conjugacy class in an abelian by nilpotent finite group is at least as large as the product of the largest class sizes for the Sylow subgroups. The example is a group having derived length 3 in which this fails.
We start with a dihedral group of order 10 acting on a cyclic group of order 8.
```magma
> E := DihedralGroup(GrpPC,5);
> A := CyclicGroup(GrpPC,8);
```
Define an action of E on A and create the split extension.
```magma
> f1 := homA|A.1->(A.1)^-1>;
> f2 := homA|A.1->A.1>;
> H := Extension(A, E, [f1, f2]);
```
Then construct a certain H-module…
```magma
> QH := SylowSubgroup(H,2);
> t := TrivialModule(QH, FiniteField(5));
> B := Induction(t, H);
```
…and form the split extension of H acting on that module.
```magma
> G := Extension(B, H);
> print G;
GrpPC : G of order 250000 = 2^4 * 5^6
PC-Relations:
G.1^2 = Id(G),
G.2^5 = Id(G),
G.3^2 = G.4,
G.4^2 = G.5,
G.5^2 = Id(G),
G.6^5 = Id(G),
G.7^5 = Id(G),
G.8^5 = Id(G),
G.9^5 = Id(G),
G.10^5 = Id(G),
G.2^G.1 = G.2^4,
G.3^G.1 = G.3 * G.4 * G.5,
G.4^G.1 = G.4 * G.5,
G.6^G.2 = G.10,
G.7^G.1 = G.10,
G.7^G.2 = G.6,
G.8^G.1 = G.9,
G.8^G.2 = G.7,
G.9^G.1 = G.8,
G.9^G.2 = G.8,
G.10^G.1 = G.7,
G.10^G.2 = G.9
> print DerivedLength(G);
3
```
Now check the relevant class sizes.
```magma
> P := SylowSubgroup(G,5);
> Q := SylowSubgroup(G,2);
> print Maximum({x[2]:x in Classes(G)});
1250
> print Maximum({x[2]:x in Classes(P)});
625
> print Maximum({x[2]:x in Classes(Q)});
4
```
Note that 1250 is less than the product 625\*4.
### Elements
Elements of a pc-group are written in terms of the generators. The pc-generators of a group $G$ can always be written as `G.1`, `G.2`, … . Any variables naming the generators, either assigned during the definition of the group, or later using standard assignment statements, can also be used to express the generators. An arbitrary element can be written as a word in the generators using the various element operations.
#### Definition of Elements
A *word* is defined inductively as follows:
**(i)**
A generator is a word;
**(ii)**
The expression $(u)$ is a word, where $u$ is a word;
**(iii)**
The product $u*v$ of the words $u$ and $v$ is a word;
**(iv)**
The conjugate $u^v$ of the word $u$ by the word $v$ is a word ($u^v$ expands into the word $v^{-1}*u*v$);
**(v)**
The power of a word $u^n$, where $u$ is a word and $n$ is an integer, is a word;
**(vi)**
The commutator $(u, v)$ of the words $u$ and $v$ is a word ( $(u, v)$ expands into the word $u^{-1}*v^{-1}*u*v$).
A group element is always printed by Magma as a normal word in the pc-generators of its parent group.
It is also possible to create an element of a group $G$ from its exponent vector. That is, the sequence $[e_1, e_2, \ldots, e_n]$ corresponds to the element ${G.1}^{e_1} * {G.2}^{e_2} * \cdots * {G.n}^{e_n}$. The coercion operator `!` is used to convert the sequence to the element.
##### `G ! Q: GrpPC, [RngIntElt] -> GrpPCElt`
Given the pc-group $G$ and a sequence $Q$ of length $n$, containing the distinct positive integers ${\alpha_i}$, $0\leq {\alpha_i} < p_{i}$ for $i = 1,\ldots,n$, construct the element $x$ of $G$ given by
$$
x = a_1^{\alpha_1}\ldots a_n^{\alpha_n}, \quad 0 \leq \alpha_i < p_i
\quad\hbox{\rm for } i = 1, \ldots, n.
$$
##### `ElementToSequence(x): GrpPCElt -> [RngIntElt]`
##### `Eltseq(x): GrpPCElt -> [RngIntElt]`
Given an element $x$ belonging to the pc-group $G$, where
$$
x = a_1^{\alpha_1}\ldots a_n^{\alpha_n}, \quad 0 \leq \alpha_i < p_i
\quad\hbox{\rm for } i = 1, \ldots, n,
$$
return the sequence $Q$ of $n$ integers defined by $Q[i] = {\alpha_i}$, for $i = 1,\ldots,n$.
##### `Identity(G): GrpPC -> GrpPCElt`
##### `Id(G): GrpPC -> GrpPCElt`
##### `G ! 1: GrpPC, RngIntElt -> GrpPCElt`
Construct the identity element of the pc-group $G$.
##### `Example: Defining Elements of a Pc-Group (ex-027472)`
Given a pc-group, we can define elements as words in the generators or as more general expressions.
```magma
> G := PolycyclicGroup;
> G;
GrpPC : G of order 12 = 2^2 * 3
PC-Relations:
G.1^3 = Id(G),
G.2^2 = Id(G),
G.3^2 = Id(G),
G.2^G.1 = G.3,
G.3^G.1 = G.2 * G.3
> x := G.1^2*G.3;
> x;
G.1^2 * G.3
> x^2;
G.1 * G.2 * G.3
> x^3;
Id(G)
```
Magma will print the element in normal form even if it is not entered that way.
```magma
> G.2*G.1;
G.1 * G.3
```
When coercing a sequence into a group element, the sequence is always interpreted as an exponent vector for a normal word.
```magma
> y := G![0,1,1];
> y;
G.2 * G.3
> x*y;
G.1^2 * G.2
> y*x;
G.1^2
> (x,y);
G.2
```
An element can also be converted into a sequence.
```magma
> x^y;
G.1^2 * G.2 * G.3
> Eltseq(x^y);
[ 2, 1, 1 ]
```
#### Arithmetic Operations on Elements
New elements can be computed from existing elements using standard operations.
##### `g * h: GrpPCElt, GrpPCElt -> GrpPCElt`
Product of the element $g$ and the element $h$, where $g$ and $h$ belong to some common subgroup $G$ of a pc-group $U$. If $g$ and $h$ are given as elements belonging to the same proper subgroup $G$ of $U$, then the result will be returned as an element of $G$; if $g$ and $h$ are given as elements belonging to distinct subgroups $H$ and $K$ of $U$, then the product is returned as an element of $G$, where $G$ is the smallest subgroup of $U$ known to contain both elements.
##### `g *:= h: GrpPCElt, GrpPCElt -> GrpPCElt`
Replace $g$ with the product of element $g$ and element $h$.
##### `g ^ n: GrpPCElt, RngIntElt -> GrpPCElt`
The $n$-th power of the element $g$, where $n$ is a positive or negative integer.
##### `g ^:= n: GrpPCElt, RngIntElt -> GrpPCElt`
Replace $g$ with the $n$-th power of the element $g$.
##### `g / h: GrpPCElt, GrpPCElt -> GrpPCElt`
Quotient of the element $g$ by the element $h$, i.e. the element $g*h^{-1}$. Here $g$ and $h$ must belong to some common subgroup $G$ of a pc-group $U$. The rules for determining the parent group of $g/h$ are the same as for $g*h$.
##### `g /:= h: GrpPCElt, GrpPCElt -> GrpPCElt`
Replace $g$ with the quotient of the element $g$ by the element $h$.
##### `g ^ h: GrpPCElt, GrpPCElt -> GrpPCElt`
Conjugate of the element $g$ by the element $h$, i.e. the element $h^{-1}*g*h$. Here $g$ and $h$ must belong to some common subgroup $G$ of a pc-group $U$. The rules for determining the parent group of $g^h$ are the same as for $g*h$.
##### `g ^:= h: GrpPCElt, GrpPCElt -> GrpPCElt`
Replace $g$ with the conjugate of the element $g$ by the element $h$.
##### `(g₁, ..., gₙ): List(GrpPCElt) -> GrpPCElt`
Given the $n$ words $g_1, \ldots, g_n$ belonging to some common subgroup $G$ of a pc-group $U$, return the commutator. If $g_1, \ldots, g_n$ are given as elements belonging to the same proper subgroup $G$ of $U$, then the result will be returned as an element of $G$; if $g_1, \ldots, g_n$ are given as elements belonging to distinct subgroups of $U$, then the product is returned as an element of $G$, where $G$ is the smallest subgroup of $U$ known to contain all elements. Commutators are *left-normed*, so that they are evaluated from left to right.
#### Properties of Elements
##### `Order(x): GrpPCElt -> RngIntElt`
Order of the element $x$.
##### `Parent(x): GrpPCElt -> GrpPC`
The parent group $G$ of the element $x$.
#### Predicates for Elements
Elements in the same group can be compared using `eq` and `ne`.
##### `g eq h: GrpPCElt, GrpPCElt -> BoolElt`
Given elements $g$ and $h$ belonging to a common pc-group, return `true` if $g$ and $h$ are the same element, `false` otherwise.
##### `g ne h: GrpPCElt, GrpPCElt -> BoolElt`
Given elements $g$ and $h$ belonging to a common pc-group, return `true` if $g$ and $h$ are distinct elements, `false` otherwise.
##### `IsIdentity(g): GrpPCElt -> BoolElt`
##### `IsId(g): GrpPCElt -> BoolElt`
Returns `true` if $g$ is the identity element, `false` otherwise.
##### `IsConjugate(G, g, h): GrpPC, GrpPCElt, GrpPCElt -> BoolElt, GrpPCElt`
Given a group $G$ and elements $g$ and $h$ belonging to $G$, return the value `true` if $g$ and $h$ are conjugate in $G$. The function also returns a second value in the event that the elements are conjugate: an element $z$ such that $g^z=h$.
##### `Example: Testing Whether Elements Commute (ex-7b7701)`
We check if one element commutes with another.
```magma
> G := PolycyclicGroup;
> b^a eq b;
false
```
The same information can also be obtained by checking the commutator.
```magma
> IsIdentity((b,a));
false
```
If we assign the result of `IsConjugate` to a single variable, it will store the boolean result.
```magma
> r := IsConjugate(G, c, b);
> r;
true
```
If we simply print `IsConjugate`, the boolean value and the conjugating element (if any) are displayed. On the other hand, using the multiple assignment, we can capture both of those values.
```magma
> IsConjugate(G, c, b);
true a^2
> r, x := IsConjugate(G, c, b);
> x, r;
a^2 true
> c^x;
b
```
#### Set Operations
These functions allow one to work with the set of elements of $G$, possibly without much knowledge of the structure of $G$.
##### `NumberingMap(G): GrpPC -> Map`
A bijective mapping from the group $G$ onto the set of integers $\{1 ... |G|\}$. The actual mapping depends upon the current presentation for $G$.
##### `Random(G): GrpPC -> GrpPCElt`
An element, randomly chosen, from the group $G$. This function uses an entirely different procedure than that used by `RandomProcess` (see below). A group element is chosen with uniform probability by generating (pseudo-)random integers in the proper range to form a legal exponent vector for $G$. The corresponding element is returned. This is an extremely efficient process and is the recommended method for producing random elements of a pc-group.
##### `RandomProcess(G): GrpPC -> Process`
```magma
Slots : RngIntElt Default: 10
Scramble: RngIntElt Default: 20
```
Create a process to generate randomly chosen elements from the group $G$. The process uses an ‘expansion’ procedure to construct a set of elements corresponding to fairly long words in the generators of $G$. At all times, $N$ elements are stored where $N$ is the maximum of the specified value for `Slots` and `Ngens`$(G) + 1$. Initially, these are simply the generators of $G$ and products of pairs of generators of $G$. Random elements are now produced by successive calls to `Random(P)`, where $P$ is the process created by this function. Each such call chooses an element $x$ stored by the process and returns it, replacing $x$ with the product of $x$ and another random element (multiplied on the left or the right). Setting `Scramble := m` causes $m$ such operations to be performed initially.
##### `Random(P): Process -> GrpPCElt`
Given a random element process $P$ created by the function `RandomProcess(G)` for the finite group $G$, construct a random element of $G$ by forming a random product over the expanded generating set constructed when the process was created.
##### `Representative(G): GrpPC -> GrpPCElt`
##### `Rep(G): GrpPC -> GrpPCElt`
A representative element of $G$. For a pc-group, this always returns the identity element.
##### `Example: Numbering Group Elements (ex-0f7a7b)`
The `NumberingMap` function assigns a number to each group element.
```magma
> G := DihedralGroup(GrpPC,4);
> num_map := NumberingMap(G);
> for x in G do
> print x,"->",num_map(x);
> end for;
Id(G) -> 1
G.3 -> 2
G.2 -> 3
G.2 * G.3 -> 4
G.1 -> 5
G.1 * G.3 -> 6
G.1 * G.2 -> 7
G.1 * G.2 * G.3 -> 8
```
The inverse map can be used to obtain the group element corresponding to a particular number.
```magma
> 6 @@ num_map;
G.1 * G.3
```
The `Random` function is sometimes useful to create a statistical profile of a group. To demonstrate, we take two groups of order $3^6$ from the `SmallGroup` database.
```magma
> G1 := SmallGroup(3^6, 60);
> G2 := SmallGroup(3^6, 392);
```
We want to build a histogram of element orders for each group. Since these are 3-groups, each order will be a power of 3 and we use `Ilog` to get the exponent of the order. First, we define a short function to compute the histogram.
```magma
> function hist(G, trials)
> // Given a 3-group G, of exponent <= 3^5,
> // return a sequence whose ith term is the
> // number of elements of order p^(i-1) out
> // of trials randomly chosen elements.
> table := [0,0,0,0,0,0];
> for i := 1 to trials do
> x := Random(G);
> n := Ilog(3, Order(x));
> table[n+1] +:= 1;
> end for;
> return table;
> end function;
```
Now, we use this function to compute order distributions for 100 elements in each group.
```magma
> t1 := hist(G1,100);
> t1;
[ 0, 0, 5, 28, 67, 0 ]
> t2 := hist(G2,100);
> t2;
[ 0, 5, 5, 25, 65, 0 ]
```
We can even display them with simple character graphics.
```magma
> for e in t1 do print ":","@"^e; end for;
:
:
: @@@@@
: @@@@@@@@@@@@@@@@@@@@@@@@@@@@
: @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
:
> for e in t1 do print ":","@"^e; end for;
:
: @@@@@
: @@@@@
: @@@@@@@@@@@@@@@@@@@@@@@@@
: @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
:
```
##### `Example: Set Product of Two Subgroups (ex-91703e)`
Given the subgroups $H$ and $K$ of $G$, construct the set product of the groups $H$ and $K$.
```magma
> set_product := func;
```
Given a subgroup $H$ of the pc-group $G$, construct $H$ as a set of elements of $G$.
```magma
> elements := func;
```
### Conjugacy
#### `Class(H, g): GrpPC, GrpPCElt -> { GrpPCElt}`
#### `Conjugates(H, g): GrpPC, GrpPCElt -> { GrpPCElt}`
#### `g ^ H: GrpPCElt, GrpPC -> { GrpPCElt}`
Given a group $H$ and an element $g$ belonging to a group $K$ such that $H$ and $K$ are subgroups of some covering group, this function returns the set of conjugates of $g$ under the action of $H$. If $H = K$, the function returns the conjugacy class of $g$ in $H$.
#### `ConjugacyClasses(G): GrpPC -> [ ]`
#### `Classes(G): GrpPC -> [ ]`
Construct a set of representatives for the conjugacy classes of $G$. The classes are returned as a sequence of tuples containing the order of the elements in the class, the class length, and a representative element for the class. For non-$p$-groups, the classes are computed using the homomorphism principle down a series with elementary abelian factors and orbit-stabilizer in each quotient. See [[MN89](https://docs.magma-maths.org/references.md#cite-mecky-neubuser)] for details. For $p$-groups an algorithm based on linear algebra developed by Charles Leedham-Green is used.
#### `ClassMap(G): GrpPC -> Map`
The class map $M\colon G \rightarrow \{1, \ldots, n\}$ for the group $G$, where $n$ is the number of conjugacy classes of $G$.
#### `ClassRepresentative(G, x): GrpPC, GrpPCElt -> GrpPCElt`
#### `ClassRepresentative(G, i): GrpPC, RngIntElt -> GrpPCElt`
The designated representative for the conjugacy class of $G$ containing the element $x$ (relative to existing conjugacy classes) or the stored representative for conjugacy class $i$.
#### `ClassCentraliser(G, i): GrpPC, RngIntElt -> GrpPCElt`
#### `ClassCentralizer(G, i): GrpPC, RngIntElt -> GrpPCElt`
The centralizer in $G$ of the designated representative for conjugacy class $i$ of $G$.
#### `IsConjugate(G, g, h): GrpPC, GrpPCElt, GrpPCElt -> BoolElt, GrpPCElt`
Given a group $G$ and elements $g$ and $h$ belonging to $G$, return the value true if $g$ and $h$ are conjugate in $G$. The function also returns a second value in the event that the elements are conjugate: an element $z$ which conjugates $g$ into $h$.
#### `NumberOfClasses(G): GrpPC -> RngIntElt`
#### `Nclasses(G): GrpPC -> RngIntElt`
The number of conjugacy classes of elements of the group $G$.
#### `PowerMap(G): GrpPC -> Map`
The power map $M\colon \{1 \ldots n\}\times {\mathbb{Z}}\rightarrow \{1 \ldots n\}$ associated with the conjugacy classes of $G$. The map $M$ describes where the elements of the conjugacy classes of $G$ move under powers. That is, $$@$M$ returns the class number where class $c$ moves under the power $n$. The value of $c$ must be in the range [$1\ldots$`Nclasses(G)`].
#### `Example: Conjugacy Classes of SL(2, 3) (ex-bdfb19)`
Let $G$ be a pc-representation of SL(2,3). We can compute the conjugacy classes of $G$. Notice that the conjugacy class object has a special printing routine, but you can still access individual entries.
```magma
> G := PCGroup(SpecialLinearGroup(2,GF(3)));
> G;
GrpPC : G of order 24 = 2^3 * 3
PC-Relations:
G.1^3 = Id(G),
G.2^2 = G.4,
G.3^2 = G.4,
G.4^2 = Id(G),
G.2^G.1 = G.3 * G.4,
G.3^G.1 = G.2 * G.3 * G.4,
G.3^G.2 = G.3 * G.4
> Nclasses(G);
7
> cc := Classes(G);
> cc;
Conjugacy Classes of group G
----------------------------
[1] Order 1 Length 1
Rep Id(G)
[2] Order 2 Length 1
Rep G.4
[3] Order 3 Length 4
Rep G.1
[4] Order 3 Length 4
Rep G.1^2
[5] Order 4 Length 6
Rep G.2
[6] Order 6 Length 4
Rep G.1 * G.4
[7] Order 6 Length 4
Rep G.1^2 * G.4
> cc[3];
<3, 4, G.1>
> x := cc[3][3];
> Class(G,x);
{ G.1 * G.2 * G.3 * G.4, G.1 * G.2 * G.4, G.1, G.1 * G.3 }
7
>
```
We can use the `ClassMap` function to compute class multiplication constants (structure constants for the center of the group algebra). For example, we compute the decomposition of class 3 times class 5.
```magma
> cm := ClassMap(G);
> cm(G.1);
3
> i := 3; j := 5;
> t := [0: c in cc];
> for x in Class(G,cc[i][3]), y in Class(G,cc[j][3]) do
> t[cm(x*y)] +:= 1;
> end for;
> t;
[ 0, 0, 12, 0, 0, 12, 0 ]
```
To get the actual structure constants, we need to divide each entry in `t` by the corresponding class size.
```magma
> [ t[i]/cc[i][2]: i in [1..#t] ];
[ 0, 0, 3, 0, 0, 3, 0 ]
```
### Subgroups
Subgroups of pc-groups are treated as independent pc-groups in their own right, with the subgroup relationship maintained in internal data structures. Thus, a subgroup has generators and a pc-presentation and one can apply any of the functions described earlier for groups. Furthermore, there are a variety of functions and operations specifically involving subgroups.
#### Definition of Subgroups by Generators
The most flexible method of defining a subgroup is to list generators or normal generators for the subgroup.
##### `sub: GrpPC, List -> GrpPC, Map`
Construct the subgroup $H$ of the pc-group $G$ generated by the elements specified by the terms of the *generator list* $L$.
A term $L[i]$ of the generator list may consist of any of the following objects:
**(a)**
An element liftable to $G$ (in particular, any element of $G$);
**(b)**
A subgroup of $G$;
**(c)**
A set or sequence of (a), or (b).
The collection of words and groups specified by the list must all belong to the group $G$ and $H$ will be constructed as a subgroup of $G$.
The subgroup $H$ is defined to be generated by the words specified directly by terms $L[i]$ together with the stored generating words for any groups specified by terms of $L[i]$. Magma will compute a set of pc-generators for $H$ and, if $H$ is a $p$-group, a minimal generating set.
The inclusion map from $H$ to $G$ is returned as well.
##### `ncl: GrpPC, List -> GrpPC, Map`
Construct the subgroup $N$ of the pc-group $G$ as the normal closure of the subgroup generated by the elements specified by the terms of the *generator list* $L$.
The possible forms of a term $L[i]$ of the generator list are the same as for the `sub`-constructor.
The inclusion map from $N$ to $G$ is returned as well.
##### `Example: Creating Subgroups by Generators (ex-9f724a)`
We define $G$ to be $Z_5$ wr $Z_3$ and then create two subgroups. Notice that the `ncl`-constructor builds a larger subgroup in this case.
```magma
> G := PolycyclicGroup b^a = c, c^a = d, d^a = b>;
> H := sub;
> Order(H);
25
> IsAbelian(H);
true
> IsNormal(G, H);
false
> N := ncl;
> IsNormal(G, N);
true
> Order(N);
125
```
#### Membership and Coercion
There are several functions and operators which allow one to take advantage of the subgroup relationship to rewrite elements from one presentation to another. That is, if $x$ is an element of $H$ which is a subgroup of $G$, then $x$ has a representation as a normal word in the pc-generators of $H$, but also has a representation as a (different) normal word in the pc-generators of $G$. The coercion operator and inclusion map allow one to compute one of these words based on the other, thus shifting where we view the element in question.
Magma keeps track of the various relationships between subgroups in a group. Thus, if $H$ is a subgroup of $K$ which is a subgroup of $G$, then $H$ can also be considered a subgroup $G$. Similarly, in situations involving elements of two groups, $A$ and $B$, Magma will often try to find a *covering group* $C$ which contains both of $A$ and $B$. In this case, the elements may be automatically coerced into the covering group.
##### `g in G: GrpPCElt, GrpPC -> BoolElt`
Given an element $g$ and a group $G$, return `true` if $g$ is an element of $G$, `false` otherwise. In order for this comparison to make sense, both $g$ and $G$ must be contained in some covering group.
##### `g notin G: GrpPCElt, GrpPC -> BoolElt`
Given an element $g$ and a group $G$, return `true` if $g$ is not an element of $G$, `false` otherwise. In order for this comparison to make sense, both $g$ and $G$ must be contained in some covering group.
##### `G ! g: GrpPC, GrpPCElt -> GrpPCElt`
Given an element $g$ belonging to some subgroup $H$ of the group $G$, rewrite $g$ as an element of $G$.
##### `H ! g: GrpPC, GrpPCElt -> GrpPCElt`
Given an element $g$ belonging to the group $G$, and given a subgroup $H$ of $G$ containing $g$, rewrite $g$ as an element of $H$.
##### `K ! g: GrpPC, GrpPCElt -> GrpPCElt`
Given an element $g$ belonging to the group $H$, and a group $K$, such that $H$ and $K$ are subgroups of a covering group $G$, and both $H$ and $K$ contain $g$, rewrite $g$ as an element of $K$.
##### `Example: Membership and Coercion in Subgroups (ex-ac7047)`
We create two subgroups of a dihedral group.
```magma
> G := DihedralGroup(GrpPC, 10);
> C := sub;
> H := sub;
> H.1 in C;
false
> H.2 in C;
true
> Parent(H.1);
GrpPC : H of order 10 = 2 * 5
PC-Relations:
H.1^2 = Id(H),
H.2^5 = Id(H),
H.2^H.1 = H.2^4
> G!(H.1);
G.1
```
Magma will compute appropriate covering groups as needed.
```magma
> H.1*C.1;
G.1 * G.2 * G.3^2
> x := (H.1, C.2);
> x;
G.3^2
> H!x;
H.2^2
> C!x;
C.2^2
> C!(H.2);
C.2
```
#### Inclusion and Equality
##### `S subset G: { GrpPCElt}, GrpPC -> BoolElt`
Given a group $G$ and a set $S$ of elements belonging to a group $H$, where $G$ and $H$ have some covering group, return `true` if $S$ is a subset of $G$, `false` otherwise.
##### `S notsubset G: { GrpPCElt}, GrpPC -> BoolElt`
Given a group $G$ and a set $S$ of elements belonging to a group $H$, where $G$ and $H$ have some covering group, return `true` if $S$ is not a subset of $G$, `false` otherwise.
##### `H subset G: GrpPC, GrpPC -> BoolElt`
##### `IsSubgroup(H, G): GrpPC, GrpPC -> BoolElt`
Given groups $G$ and $H$, subgroups of some covering group, return `true` if $H$ is a subgroup of $G$, `false` otherwise.
##### `H notsubset G: GrpPC, GrpPC -> BoolElt`
Given groups $G$ and $H$, subgroups of some covering group, return `true` if $H$ is not a subgroup of $G$, `false` otherwise.
##### `G eq H: GrpPC, GrpPC -> BoolElt`
Given groups $G$ and $H$, subgroups of some covering group, return `true` if $G$ and $H$ are the same group, `false` otherwise.
##### `G ne H: GrpPC, GrpPC -> BoolElt`
Given groups $G$ and $H$, subgroups of some covering group, return `true` if $G$ and $H$ are distinct groups, `false` otherwise.
##### `InclusionMap(G, H): GrpPC, GrpPC -> Map`
The map from the subgroup $H$ of $G$ to $G$.
#### Standard Subgroup Constructions
The operators and functions which construct a subgroup of a pc-group always return the subgroup as a pc-group.
##### `H ^ g: GrpPC, GrpPCElt -> GrpPC`
##### `Conjugate(H, g): GrpPC, GrpPCElt -> GrpPC`
Construct the conjugate $g^{-1}*H*g$ of the group $H$ under the action of the element $g$. The group $H$ and the element $g$ must belong to a common group.
##### `H meet K: GrpPC, GrpPC -> GrpPC`
The intersection of groups $H$ and $K$. The algorithm used for non-$p$-groups is described in [[GS90](https://docs.magma-maths.org/references.md#cite-gs-intnorm)].
##### `H meet:= K: GrpPC, GrpPC -> GrpPC`
Replace $H$ with the intersection of groups $H$ and $K$.
##### `CommutatorSubgroup(G, H, K): GrpPC, GrpPC, GrpPC -> GrpPC`
##### `CommutatorSubgroup(H, K): GrpPC, GrpPC -> GrpPC`
Construct the commutator subgroup of groups $H$ and $K$, where $H$ and $K$ are subgroups of a common group $G$.
##### `Centralizer(G, g): GrpPC, GrpPCElt -> GrpPC`
##### `Centraliser(G, g): GrpPC, GrpPCElt -> GrpPC`
The centralizer of the element $g$ in the group $G$.
##### `Centralizer(G, H): GrpPC, GrpPC -> GrpPC`
##### `Centraliser(G, H): GrpPC, GrpPC -> GrpPC`
The centralizer of the subgroup $H$ in the group $G$.
##### `Core(G, H): GrpPC, GrpPC -> GrpPC`
The maximal normal subgroup of $G$ that is contained in the subgroup $H$ of $G$.
##### `H ^ G: GrpPC, GrpPC -> GrpPC`
##### `NormalClosure(G, H): GrpPC, GrpPC -> GrpPC`
The normal closure of the subgroup $H$ in the group $G$.
##### `Normalizer(G, H): GrpPC, GrpPC -> GrpPC`
##### `Normaliser(G, H): GrpPC, GrpPC -> GrpPC`
The normalizer of the subgroup $H$ of the group $G$. The algorithm used for non-$p$-groups is described in [[GS90](https://docs.magma-maths.org/references.md#cite-gs-intnorm)].
##### `Example: Subgroup Constructions (ex-38016c)`
We’ll consider various subgroups of a direct product of a cyclic group of order 6 and dihedral group of order 10.
```magma
> G := DirectProduct(CyclicGroup(GrpPC,6), DihedralGroup(GrpPC,5));
> x := G.3;
> C := Centralizer(G,x);
> C;
GrpPC : C of order 12 = 2^2 * 3
PC-Relations:
C.1^2 = Id(C),
C.2^2 = Id(C),
C.3^3 = Id(C)
> H := sub;
> Order(H);
15
```
We can compute the intersection using the `meet` operator.
```magma
> K := H meet C;
> K;
GrpPC : K of order 3
PC-Relations:
K.1^3 = Id(K)
```
To get the join of two subgroups, we simply use the `sub`-constructor.
```magma
> J := sub;
> J eq G;
true
```
#### Properties of Subgroups
##### `Index(G, H): GrpPC, GrpPC -> RngIntElt`
The index of the subgroup $H$ in the group $G$, returned as an ordinary integer.
##### `FactoredIndex(G, H): GrpPC, GrpPC -> []`
The factored index of the subgroup $H$ in the group $G$.
#### Predicates for Subgroups
##### `IsCentral(G, H): GrpPC, GrpPC -> BoolElt`
Returns `true` if the subgroup $H$ of the group $G$ lies in the centre of $G$, `false` otherwise.
##### `IsConjugate(G, H, K): GrpPC, GrpPC, GrpPC -> BoolElt, GrpPCElt`
Given a group $G$ and subgroups $H$ and $K$ belonging to $G$, return the value `true` if $H$ and $K$ are conjugate in $G$. The function returns a second value in the event that the subgroups are conjugate: an element $z$ which conjugates $H$ into $K$.
##### `IsMaximal(G, H): GrpPC, GrpPC -> BoolElt`
Returns `true` if the subgroup $H$ of the group $G$ is a maximal subgroup of $G$, `false` otherwise.
##### `IsNormal(G, H): GrpPC, GrpPC -> BoolElt`
Returns `true` if the subgroup $H$ of the group $G$ is a normal subgroup of $G$, `false` otherwise.
##### `IsSelfNormalizing(G, H): GrpPC, GrpPC -> BoolElt`
Returns `true` if the subgroup $H$ of the group $G$ is self-normalizing in $G$, `false` otherwise.
##### `IsSubnormal(G, H): GrpPC, GrpPC -> BoolElt`
Returns `true` if the subgroup $H$ of the group $G$ is subnormal in $G$, `false` otherwise.
##### `Example: Predicates for Subgroups (ex-340cb9)`
```magma
> G := PCGroup(Sym(4));
> G;
GrpPC : G of order 24 = 2^3 * 3
PC-Relations:
G.1^2 = Id(G),
G.2^3 = Id(G),
G.3^2 = Id(G),
G.4^2 = Id(G),
G.2^G.1 = G.2^2,
G.3^G.1 = G.3 * G.4,
G.3^G.2 = G.4,
G.4^G.2 = G.3 * G.4
> U := sub;
> IsNormal(G,U);
false
> IsSubnormal(G,U);
true
```
Now, we try to construct a subnormal chain by taking normalizers.
```magma
> N1 := Normalizer(G,U);
> Index(G,N1);
3
> N2 := Normalizer(G,N1);
> Index(G,N2);
3
> N1 eq N2;
true
```
We’re stuck. However, we can work our way down with `NormalClosure`.
```magma
> M1 := NormalClosure(G,U);
> U subset M1;
true
> M1 subset U;
false
> M2 := NormalClosure(M1,U);
> M2 eq U;
true
```
Now, we work inside the Sylow 2-subgroup and look for complements of the cyclic group of order 4 by brute force.
```magma
> S := Sylow(G,2);
> S;
GrpPC : S of order 8 = 2^3
PC-Relations:
S.2^S.1 = S.2 * S.3
> T := sub;
> list := [];
> for x in S do
> if (Order(x) ne 2) or (x in T) then
> continue;
> end if;
> Append(~list, sub);
> end for;
> #list;
4
> for i in [1..3], j in [i+1..4] do
> print i,j,IsConjugate(S,list[i],list[j]);
> end for;
1 2 true S.1
1 3 false
1 4 false
2 3 false
2 4 false
3 4 true S.2
```
We see that $T$ has two conjugacy classes of complements.
#### Hall $\pi$-Subgroups and Sylow Systems
The functions given here all assume that $G$ is a soluble group having order $p_{1}^{e_1}p_{2}^{e_2} \cdots p_{k}^{e_k}$.
##### `ComplementBasis(G): GrpPC -> [GrpPC]`
A complement basis of the soluble group $G$. This is a sequence of $k$ subgroups of $G$, where the $i$-th subgroup has order $p_{1}^{e_{1}} \ldots p_{i - 1}^ {e_{i - 1}} p_{i + 1}^{e_{i + 1}} \ldots p_{k}^{e_{k}}$, i.e. the complements of the $k$ Sylow subgroups of $G$.
##### `HallSubgroup(G, S): GrpPC, { RngIntElt} -> GrpPC`
##### `HallSubgroup(G, S): GrpPC, RngIntElt -> GrpPC`
The Hall $\pi$-subgroup of $G$, where $\pi$ is defined by $S$. The argument $S$ may be a set of primes, a single prime, or the negation of a single prime. If $S = -p$, then the Hall $p'$-subgroup of $G$ is returned.
##### `pCore(G, S): GrpPC, { RngIntElt} -> GrpPC`
##### `pCore(G, S): GrpPC, RngIntElt -> GrpPC`
The core of the Hall $\pi$-subgroup, where $\pi$ is defined by the argument $S$, which has the same interpretation as for `HallSubgroup`.
##### `SylowBasis(G): GrpPC -> [GrpPC]`
A Sylow basis for the soluble group $G$. This is a sequence of $k$ subgroups of $G$, having orders $p_{1}^{e_{1}}, \ldots, p_{k}^{e_{k}}$, i.e. the $k$ Sylow subgroups of $G$.
##### `SylowSubgroup(G, p): GrpPC, RngIntElt -> GrpPC`
##### `Sylow(G, p): GrpPC, RngIntElt -> GrpPC`
A Sylow $p$-subgroup for the group $G$.
##### `SystemNormalizer(G): GrpPC -> GrpPC`
##### `SystemNormaliser(G): GrpPC -> GrpPC`
The system normalizer for the group $G$. The system normalizer of the complement basis $\Sigma = \lbrace H_1,...,H_k\rbrace$ is defined to be the intersection of the normalizers in G of each $H_i$, ie. $N(\Sigma) = \cap_{i=1}^{k} N_G(H_i)$. The algorithm used is derived directly from the definition.
##### `Example: Hall Subgroups of a Wreath Product (ex-475f0f)`
Given the group $D_3 \wr D_5$, we can construct the Hall 2-subgroup as follows:
```magma
> H := DihedralGroup(GrpPerm, 5);
> G := WreathProduct(DihedralGroup(GrpPC, 3), DihedralGroup(GrpPC, 5),
> [H.2, H.1]);
> H2 := HallSubgroup(G, 2);
> Order(H2);
64
```
The Hall $2'$-subgroup of the same group is constructed as follows:
```magma
> H35 := HallSubgroup(G, -2);
> Order(H35);
1215
```
#### Conjugacy Classes of Subgroups
Magma has functions for computing the subgroups of a group that return the subgroups either as a list of conjugacy class representatives as or as a poset. Details of these functions may be found in Chapter [Groups](https://docs.magma-maths.org/FiniteGroups/Groups/index-groups.md#chapgrp). Here we mention the basic functions for convenience.
##### `SubgroupClasses(G): GrpPC -> SeqEnum`
##### `Subgroups(G): GrpPC -> SeqEnum`
Conjugacy class representatives for all subgroups of $G$. The algorithm was developed by M. Slattery and is essentially that of [[Hul99](https://docs.magma-maths.org/references.md#cite-hulpke-subs)] without the action of automorphisms.
##### `AbelianSubgroups(G): GrpPC -> SeqEnum`
##### `CyclicSubgroups(G): GrpPC -> SeqEnum`
##### `ElementaryAbelianSubgroups(G): GrpPC -> SeqEnum`
##### `NilpotentSubgroups(G): GrpPC -> SeqEnum`
Conjugacy class representatives for all subgroups of the indicated type in $G$. The algorithm used is essentially that of [[Hul99](https://docs.magma-maths.org/references.md#cite-hulpke-subs)] without the action of automorphisms. Appropriate filters are applied to select the desired groups at each successive quotient in the computation.
##### `LowIndexSubgroups(G, n): GrpPC, RngIntElt -> []`
Conjugacy class representatives for all subgroups of $G$ having index $\le n$ in $G$.
##### `MaximalSubgroups(G): GrpPC -> [GrpPC]`
A sequence of conjugacy class representatives for the maximal subgroups of $G$. The algorithm, developed by Charles Leedham-Green, relies on computing a special presentation for $G$.
##### `SubgroupLattice(G): GrpPC -> SubGrpLat`
The lattice of conjugacy classes of subgroups of $G$.
##### `BurnsideMatrix(G): GrpPC -> AlgMatElt`
The Burnside matrix corresponding to the lattice of subgroups of $G$. The $(i,j)$th entry of the matrix is the number of subgroups in class $i$ contained in a single subgroup of class $j$ when $i\le j$, and is the number of subgroups of class $i$ containing a given subgroup in class $j$ when $i\ge j$.
##### `TableOfMarks(G): GrpPC -> AlgMatElt`
Burnside’s table of marks corresponding to the lattice of subgroups of $G$. Rows correspond to marks for transitive permutation representations of $G$, while the entries in column $j$ are the number of fixed points of subgroup class $j$ in each transitive representation.
##### `DisplayBurnsideMatrix(G): GrpPC`
Pretty-print the Burnside matrix corresponding to the lattice of subgroups of $G$.
##### `Example: Subgroup Classes (ex-cf7628)`
To show a bit about subgroup classes, we look at the direct product of $C_3$ and $D_3$. First we list out the normal subgroups of $G$.
```magma
> G := DirectProduct(CyclicGroup(GrpPC,3),
> DihedralGroup(GrpPC,3));
> ns := NormalSubgroups(G);
> ns;
Conjugacy classes of subgroups
------------------------------
[1] Order 1 Length 1
GrpPC of order 1
PC-Relations:
[2] Order 3 Length 1
GrpPC of order 3
PC-Relations:
$.1^3 = Id($)
[3] Order 3 Length 1
GrpPC of order 3
PC-Relations:
$.1^3 = Id($)
[4] Order 6 Length 1
GrpPC of order 6 = 2 * 3
PC-Relations:
$.1^2 = Id($),
$.2^3 = Id($),
$.2^$.1 = $.2^2
[5] Order 9 Length 1
GrpPC of order 9 = 3^2
PC-Relations:
$.1^3 = Id($),
$.2^3 = Id($)
[6] Order 18 Length 1
GrpPC of order 18 = 2 * 3^2
PC-Relations:
$.1^2 = Id($),
$.2^3 = Id($),
$.3^3 = Id($),
$.3^$.1 = $.3^2
```
The normal subgroups sequence has a special printing routine. Each entry in the sequence is actually a record.
```magma
> ns[2];
rec |
order := 3, length := 1, subgroup := GrpPC of order 3
PC-Relations:
$.1^3 = Id($)>
```
We extract the two normal subgroups of order 3. Each of them turn out to have one conjugacy class of complements in $G$. However, one of the complements is normal and the other is not.
```magma
> N1 := ns[2]`subgroup;
> N2 := ns[3]`subgroup;
> c1 := Complements(G,N1);
> c1;
[
GrpPC of order 6 = 2 * 3
PC-Relations:
$.1^2 = Id($),
$.2^3 = Id($),
$.2^$.1 = $.2^2
]
> c2 := Complements(G,N2);
> c2;
[
GrpPC of order 6 = 2 * 3
PC-Relations:
$.1^2 = Id($),
$.2^3 = Id($)
]
> Index(G,Normalizer(G,c1[1]));
1
> Index(G,Normalizer(G,c2[1]));
3
```
We can look at the full list of classes of subgroups of $G$ to see that there are three classes of non-normal subgroups as well as the normal subgroups. There are two non-normal subgroups of order 3 in addition to $N1$ and $N2$.
```magma
> Subgroups(G);
Conjugacy classes of subgroups
------------------------------
[ 1] Order 1 Length 1
GrpPC of order 1
PC-Relations:
[ 2] Order 2 Length 3
GrpPC of order 2
PC-Relations:
$.1^2 = Id($)
[ 3] Order 3 Length 1
GrpPC of order 3
PC-Relations:
$.1^3 = Id($)
[ 4] Order 3 Length 1
GrpPC of order 3
PC-Relations:
$.1^3 = Id($)
[ 5] Order 3 Length 2
GrpPC of order 3
PC-Relations:
$.1^3 = Id($)
[ 6] Order 6 Length 1
GrpPC of order 6 = 2 * 3
PC-Relations:
$.1^2 = Id($),
$.2^3 = Id($),
$.2^$.1 = $.2^2
[ 7] Order 6 Length 3
GrpPC of order 6 = 2 * 3
PC-Relations:
$.1^2 = Id($),
$.2^3 = Id($)
[ 8] Order 9 Length 1
GrpPC of order 9 = 3^2
PC-Relations:
$.1^3 = Id($),
$.2^3 = Id($)
[ 9] Order 18 Length 1
GrpPC of order 18 = 2 * 3^2
PC-Relations:
$.1^2 = Id($),
$.2^3 = Id($),
$.3^3 = Id($),
$.3^$.1 = $.3^2
```
### Quotient Groups
#### Construction of Quotient Groups
One of the strengths of representing groups with polycyclic or power-conjugate presentations is that arbitrary quotient groups can be computed. Given (generators for) a normal subgroup of a pc-group, Magma will compute a pc-presentation for the quotient and the corresponding canonical homomorphism.
The `pQuotient` function, which can be used to find a prime-power quotient of a finitely-presented group, can also be used to compute quotients of pc-groups.
##### `quo: GrpPC, List -> GrpPC, Map`
Construct the quotient $Q$ of the pc-group $G$ by the normal subgroup $N$, where $N$ is the smallest normal subgroup of $G$ containing the elements specified by the terms of the *generator list* $L$.
The possible forms of a term $L[i]$ of the generator list are the same as for the `sub`-constructor.
The quotient group $Q$ and the corresponding natural homomorphism $f : G \rightarrow Q$ are returned.
##### `G / N: GrpPC, GrpPC -> GrpPC`
Given a normal subgroup $N$ of the pc-group $G$, construct the quotient of $G$ by $N$.
##### `Example: Quotient Groups of a Pc-Group (ex-934992)`
We will compute $O_{3',3}(G)$, where $G$ is a pc-representation of the symmetric group $S_4$. The subgroup is defined by $O_{3',3}(G)/O_{3'}(G) = O_3(G/O_{3'}(G))$.
```magma
> G := PCGroup(Sym(4));
> N := pCore(G,-3);
> Q,f := quo;
> Q;
GrpPC : Q of order 6 = 2 * 3
PC-Relations:
Q.1^2 = Id(Q),
Q.2^3 = Id(Q),
Q.2^Q.1 = Q.2^2
> S := pCore(Q,3);
> H := S @@ f;
> H;
GrpPC : H of order 12 = 2^2 * 3
PC-Relations:
H.1^3 = Id(H),
H.2^2 = Id(H),
H.3^2 = Id(H),
H.2^H.1 = H.2 * H.3,
H.3^H.1 = H.2
```
#### Abelian and $p$-Quotients
A number of standard quotients may be constructed.
##### `AbelianQuotient(G): GrpPC -> GrpAb, Map`
The maximal abelian quotient $G/G^\prime$ of the group $G$ as [`GrpAb`](https://docs.magma-maths.org/FinitelyPresentedGroups/AbelianGroups/index-abelian-groups.md#chapgrpab) (cf. Chapter [Abelian Groups](https://docs.magma-maths.org/FinitelyPresentedGroups/AbelianGroups/index-abelian-groups.md#chapgrpab)). The natural epimorphism $\pi:G\ar G/G^\prime$ is returned as second value.
##### `AbelianQuotientInvariants(G): GrpPC -> SeqEnum`
##### `AQInvariants(G): GrpPC -> SeqEnum`
A sequence of integers giving the abelian invariants of the maximal abelian quotient of $G$.
##### `ElementaryAbelianQuotient(G, p): GrpPC, RngIntElt -> GrpAb, Map`
The maximal $p$-elementary abelian quotient $Q$ of the group $G$ as [`GrpAb`](https://docs.magma-maths.org/FinitelyPresentedGroups/AbelianGroups/index-abelian-groups.md#chapgrpab) (cf. Chapter [Abelian Groups](https://docs.magma-maths.org/FinitelyPresentedGroups/AbelianGroups/index-abelian-groups.md#chapgrpab)). The natural epimorphism $\pi:G\ar Q$ is returned as second value.
##### `pQuotient(G, p, c : parameters): GrpPC, RngIntElt, RngIntElt -> GrpPC, Map`
```magma
Workspace : RngIntElt Default: 5000000
Metabelian: BoolElt Default: false
Exponent : RngIntElt Default: 0
Print : RngIntElt Default: 0
```
Given a pc-group $G$, a prime $p$, and a positive integer $c$, this function constructs a consistent power-conjugate presentation for the largest $p$-quotient $P$ of $G$ having lower exponent-$p$ class at most $c$. If $c$ is given as zero, then the limit 127 is placed on the class. The prime $p$ must be less than $65536$.
The function also returns the natural homomorphism $\pi$ from $G$ to $P$, a sequence $S$ describing the definitions of the pc-generators of $P$ and a flag indicating whether $P$ is the maximal $p$-quotient of $G$.
The $k$-th element of $S$ is a sequence of two integers, describing the definition of the $k$-th pc-generator $P.k$ of $P$ as follows.
- If $S[k] = [0,r]$, then $P.k$ is defined via the image of $G.r$ under $\pi$.
- If $S[k] = [r,0]$, then $P.k$ is defined via the power relation for $P.r$.
- If $S[k] = [r,s]$, then $P.k$ is defined via the conjugate relation involving $P.r^{P.s}$.
### Normal Subgroups and Subgroup Series
#### Characteristic Subgroups
##### `Centre(G): GrpPC -> GrpPC`
##### `Center(G): GrpPC -> GrpPC`
The centre of the group $G$.
##### `CommutatorSubgroup(G): GrpPC -> GrpPC`
##### `DerivedSubgroup(G): GrpPC -> GrpPC`
##### `DerivedGroup(G): GrpPC -> GrpPC`
The derived subgroup of the group $G$.
##### `FittingSubgroup(G): GrpPC -> GrpPC`
##### `FittingGroup(G): GrpPC -> GrpPC`
The Fitting subgroup of the group $G$.
##### `FrattiniSubgroup(G): GrpPC -> GrpPC`
The Frattini subgroup of the group $G$.
##### `PrefrattiniSubgroup(G): GrpPC -> GrpPC`
A prefrattini subgroup of the group $G$.
##### `FrattiniQuotientRank(G): GrpPC -> GrpPC`
The rank of the Frattini quotient of the $p$-group $G$.
##### `Hypercentre(G): GrpPC -> GrpPC`
##### `Hypercenter(G): GrpPC -> GrpPC`
The hypercentre of the group $G$, i.e. the stationary term in the upper central series for $G$.
##### `MinimalNormalSubgroups(G): GrpPC -> [GrpPC]`
A sequence containing all minimal normal subgroups of $G$.
##### `pCore(G, S): GrpPC, { RngIntElt} -> GrpPC`
##### `pCore(G, S): GrpPC, RngIntElt -> GrpPC`
The maximal normal $\pi$-subgroup of $G$, $O_{\pi}(G)$, where $\pi$ is defined by $S$. The argument $S$ may be a set of primes, a single prime, or the negation of a single prime. If $S = -p$, then $O_{p'}(G)$ is returned.
##### `Socle(G): GrpPC -> GrpPC`
The socle of $G$.
#### Subgroup Series
##### `PrimaryAbelianBasis(G): GrpPC -> [ GrpPCElt ], [ RngIntElt ]`
##### `AbelianBasis(G): GrpPC -> [ GrpPCElt ], [ RngIntElt ]`
Given an abelian group $G$, return sequences $B$ and $I$ such that ${\rm order}(B[i]) = I[i]$ and $\langle B\rangle = G$ and the terms of $I$ give the types of each $p$-primary component of $G$. The non-primary form uses the Smith form invariants, i.e. each element of the sequence divides the next.
##### `PrimaryAbelianInvariants(G): GrpPC -> [RngIntElt]`
##### `AbelianInvariants(G): GrpPC -> [RngIntElt]`
Given an abelian group $G$, return a sequence $Q$ containing the types of each $p$-primary component of $G$. The non-primary form gives the Smith form invariants, i.e. each element of the sequence divides the next.
##### `ChiefSeries(G): GrpPC -> [GrpPC]`
A chief series for the group $G$. The series is returned as a sequence of subgroups of $G$.
##### `CompositionSeries(G): GrpPC -> [GrpPC]`
A composition series for the group $G$. The series is returned as a sequence of subgroups of $G$. The $i$-th term of the composition series has a presentation given by the generators `G.i` through `G.NPCgens(G)` and relations involving those generators only.
##### `CompositionFactors(G): GrpPC -> SeqEnum`
A sequence of integer tuples that describe the composition factors, ordered according to some composition series for the group $G$. Since each factor will be a cyclic group of prime order, the tuples will each be of the form $<19,0,q>$ representing the cyclic group of order $q$. The sequence has a custom print routine.
##### `CompositionSeries(G, i): GrpPC, RngIntElt -> [GrpPC]`
The $i+1$-th entry of the composition series for the group $G$. Its presentation is given by the generators `G.(i+1)` through `G.m`, where $m$ is the number of pc-generators of $G$ and relations involving these generators only.
##### `DerivedSeries(G): GrpPC -> [GrpPC]`
The derived series of the group $G$. The series is returned as a sequence of subgroups.
##### `DerivedLength(G): GrpPC -> RngIntElt`
The derived length of the group $G$.
##### `ElementaryAbelianSeries(G): GrpPC -> [GrpPC]`
An elementary abelian series is a chain of normal subgroups with the property that the quotient of each pair of successive terms in the series is elementary abelian. The elementary abelian series for the group $G$ is returned as a sequence of subgroups.
##### `ElementaryAbelianSeriesCanonical(G): GrpPC -> [GrpPC]`
Gives a similar result to using `ElementaryAbelianSeries`, except the series returned depends only on the isomorphism type of the group, and consists of characteristic subgroups. This function may be slower than `ElementaryAbelianSeries`.
##### `LowerCentralSeries(G): GrpPC -> [GrpPC]`
The lower central series for the group $G$. The series is returned as a sequence of subgroups.
##### `NilpotencyClass(G): GrpPC -> RngIntElt`
If $G$ is nilpotent, return the nilpotence class of $G$. Otherwise, -1 is returned.
##### `pCentralSeries(G, p): GrpPC, RngIntElt -> [GrpPC]`
The $p$-central series for $G$, where $p$ is a prime dividing $|G|$. The series is returned as a sequence of subgroups. The $p$-central series $P_1 \triangleright P_2 \triangleright \cdots \triangleright P_i$ of a soluble group $G$ is defined inductively as follows:
**•**
$P_1 = G$,
**•**
$P_{i+1} = (G, P_i)P_i^p$, for $i > 0$.
##### `SubnormalSeries(G, H): GrpPC, GrpPC -> [GrpPC]`
Given a group $G$ and a subgroup $H$ of $G$, return a sequence of subgroups commencing with $G$ and terminating with $H$, such that each subgroup is normal in the previous one. If $H$ is not subnormal in $G$, the empty sequence is returned.
##### `UpperCentralSeries(G): GrpPC -> [GrpPC]`
The upper central series of $G$. The series is returned as a sequence of subgroups.
##### `Example: Elementary Abelian Series (ex-54e655)`
The elementary abelian series of the group $D_3 \wr D_5$ has terms of the following orders:
```magma
> H := DihedralGroup(GrpPerm, 5);
> G := WreathProduct(DihedralGroup(GrpPC, 3), DihedralGroup(GrpPC, 5),
> [H.2, H.1]);
> EAS := ElementaryAbelianSeries(G);
> for i := 1 to #EAS do
> print FactoredOrder(EAS[i]);
> end for;
[ <2, 6>, <3, 5>, <5, 1> ]
[ <2, 4>, <3, 5>, <5, 1> ]
[ <2, 4>, <3, 5> ]
[ <3, 5> ]
[]
```
Hence the elementary abelian factors can be seen to have sizes $2^2$, $5$, $2^4$, and $3^5$, reading from top to bottom.
#### Series for $p$-groups
The following functions are only defined for a pc-group which is a $p$-group.
##### `Agemo(G, i): GrpPC, RngIntElt -> GrpPC`
Given a $p$-group $G$, return the characteristic subgroup of $G$ generated by the elements $x^{p^i}$, $x \in G$, where $i$ is a positive integer.
##### `Omega(G, i): GrpPC, RngIntElt -> GrpPC`
Given a $p$-group $G$, return the characteristic subgroup of $G$ generated by the elements of order dividing $p^i$, where $i$ is a positive integer.
##### `JenningsSeries(G): GrpPC -> [GrpPC]`
Given a $p$-group $G$, return the Jennings series for $G$. The series is returned as a sequence of subgroups. The Jennings series $J_1 \triangleright J_2 \triangleright \cdots \triangleright J_i \cdots$ of a $p$-group $G$ is defined inductively as follows:
**•**
$J_1 = G$,
**•**
$J_{i+1} = <(J_i, G), J_k^p>$, with $k = \lceil (i+1)/p\rceil$, $i > 0$.
##### `pClass(G): GrpPC -> RngIntElt`
The lower exponent-$p$ class of the $p$-group $G$.
##### `pRanks(G): GrpPC -> [ RngIntElt ]`
A sequence whose $i$-th entry is the number of pc-generators for the lower exponent-$p$ class $i$ quotient of the $p$-group $G$.
#### Normal Subgroups and Complements
##### `NormalSubgroups(G): GrpPC -> SeqEnum`
The collection of all normal subgroups of $G$ returned as a sequence.
##### `NormalLattice(G): GrpPC -> SubGrpLat`
The lattice of normal subgroups of $G$.
##### `MinimalNormalSubgroup(G): GrpPC -> GrpPC`
An elementary abelian minimal normal subgroup of the soluble group $G$.
##### `MinimalNormalSubgroup(G, N): GrpPC -> GrpPC`
Given a non-trivial, normal subgroup $N$ of $G$, return an elementary abelian minimal normal subgroup of $G$ contained in $N$.
##### `Complements(G, N): GrpPC, GrpPC -> SeqEnum`
Given a normal subgroup $N$ of $G$, return conjugacy class representatives of all complements of $N$ in $G$. This function implements the first cohomology computation described in [[CNW90](https://docs.magma-maths.org/references.md#cite-cnw-compls)].
##### `NormalComplements(G, N): GrpPC, GrpPC -> SeqEnum`
Given a normal subgroup $N$ of $G$, return all normal complements of $N$ in $G$. This function implements the first cohomology computation described in [[CNW90](https://docs.magma-maths.org/references.md#cite-cnw-compls)].
##### `NormalComplements(G, H, N): GrpPC, GrpPC, GrpPC -> SeqEnum`
Given a normal subgroup $N$ of $G$, and a normal subgroup $H$ of $G$ containing $N$, return all complements of $N$ in $H$ which are normal in $G$. This function implements the first cohomology computation described in [[CNW90](https://docs.magma-maths.org/references.md#cite-cnw-compls)].
##### `Example: Normal Complements (ex-12efb9)`
We define the direct product of an extraspecial group of order $3^3$ and $D_3$ and let $N$ be the first factor of this product. Inside the Sylow 3-subgroup, we see that $N$ has 11 classes of complements, three of which are normal.
```magma
> A := ExtraSpecialGroup(GrpPC,3,1);
> B := DihedralGroup(GrpPC,3);
> G,f,p := DirectProduct(A,B);
> N := f[1](A);
> S3 := Sylow(G,3);
> cS := Complements(S3,N);
> [Index(S3,Normalizer(S3,t)):t in cS];
[ 1, 1, 1, 3, 3, 3, 3, 3, 3, 3, 3 ]
```
We can compute only the normal complements by using `NormalComplements`.
```magma
> ncS := NormalComplements(S3,N);
> #ncS;
3
```
We can check that precisely one of these three complements is actually normal in $G$.
```magma
> [IsNormal(G,t):t in ncS];
[ true, false, false ]
```
Since $N$ has a $G$-normal complement in $S3$, we must have $S3$ normal in $G$. We can verify this. Using the three-parameter version of `NormalComplements` we can directly compute the $G$-normal complements of $N$ in $S3$.
```magma
> IsNormal(G,S3);
true
> ncG := NormalComplements(G,S3,N);
> #ncG;
1
> #NormalComplements(G,N);
1
```
### Cosets
#### Coset Tables and Transversals
##### `Transversal(G, H): GrpPC, GrpPC -> {@ GrpPCElt @}, Map`
##### `RightTransversal(G, H): GrpPC, GrpPC -> {@ GrpPCElt @}, Map`
Given a group $G$ and a subgroup $H$ of $G$, this function returns
**(a)**
An indexed set of elements $T$ of $G$ forming a right transversal for $G$ over $H$; and
**(b)**
The corresponding transversal mapping $\phi: G \rightarrow T$. If $T = [t_1, \ldots, t_r]$ and $g$ in $G$, $\phi$ is defined by $\phi(g) = t_i$, where $g\in H*t_i$.
##### `CosetTable(G, H): GrpPC, GrpPC -> Map`
Given a group $G$ and a subgroup $H$ of $G$ of index $r$, return a mapping $M:\langle\{1..r\},G\rangle\rightarrow\{1..r\}$ describing the action of $G$ on the (right) cosets of $H$.
##### `Transversal(G, H, K): GrpPC, GrpPC, GrpPC -> {@ GrpPCElt @}, Map`
An indexed set of representatives for the double cosets $HuK$ in $G$, and the corresponding transversal mapping. The algorithm used is described in [[Sla01](https://docs.magma-maths.org/references.md#cite-slat-cosets)].
##### `ShortCosets(p, H, G): GrpPCElt, GrpPC, GrpPC -> [GrpPCElt]`
Computes a set of representatives for the transversal of $G$ modulo $H$ of all cosets that contain $p$. This computation does not do a full transversal of $G$ modulo $H$ and may therefore be used even if the index of $(G:H)$ is very large.
#### Action on a Coset Space
##### `CosetAction(G, H): Grp, Grp -> Hom(Grp), GrpPerm, GrpPC`
Given a subgroup $H$ of the group $G$, construct the permutation representation of $G$ given by the action of $G$ on the set of (right) cosets of $H$ in $G$. The function returns:
**(a)**
The natural homomorphism $f: G \rightarrow L$;
**(b)**
The induced group $L$;
**(c)**
The kernel $K$ of the action (a subgroup of $G$).
##### `CosetImage(G, H): Grp, Grp -> GrpPerm`
Given a subgroup $H$ of the group $G$, construct the image $L$ of $G$ given by the action of $G$ on the set of (right) cosets of $H$ in $G$. $L$ is returned as a permutation group.
##### `CosetKernel(G, H): Grp, Grp -> Grp`
Given a subgroup $H$ of the group $G$, construct the kernel of the action of $G$ on the set of (right) cosets of $H$ in $G$.
### Automorphism Group
#### General Soluble Group
In the case of a soluble non-$p$-group there are two algorithms available. By default, a lifting-based algorithm developed by M. Smith [[Smi94](https://docs.magma-maths.org/references.md#cite-smith-thesis)] and extended by Smith and Slattery to use second cohomology is used. Alternatively, there is also an algorithm developed by D. Howden [[How12](https://docs.magma-maths.org/references.md#cite-howden-thesis)], which uses the automorphism group of a Sylow $p$-subgroup of $G$ to construct the automorphism group of $G$.
##### Lifting Algorithm
The automorphism group is computed step-by-step considering a series of factors of $G$ by terms of a characteristic series
$$
G = G_1 > G_2 > \cdots > G_k > 1
$$
such that $G_i/G_{i+1}$ is elementary abelian for each $i$. We compute the automorphism group ${\operatorname{Aut}}(G/G_2)\cong{\operatorname{GL}}(d,p)$ for some integer $d$ and prime $p$, and then lift through each of the elementary abelian layers $G/G_3,\dots, G/G_{k-1}$, finally arriving at ${\operatorname{Aut}}(G/G_k) = {\operatorname{Aut}}(G)$. A group of type `GrpAuto` is returned. Details of the computation can be seen by setting the verbose flag `AutomorphismGroup` to `true`, and the characteristic series is available as the attribute `CharacteristicSeries` on the returned group. In addition to the usual properties of `GrpAuto` (such as `Order`, `Ngens`, etc.), two special fields, `GenWeights` and `WeightSubgroupOrders`, are provided for automorphism groups of (non $p$-group) pc-groups. These each relate to weight subgroups of the automorphism group. Let $i$ be the largest subscript such that the automorphism acts trivially on $G/G_i$. Then the automorphism is said to have weight $2i+1$ if it acts non-trivially on $G_i/G_{i+1}$, and weight $2i+2$ if it acts trivially on $G_i/G_{i+1}$. Note that there are no automorphisms of weight 2. The automorphisms of weight greater than or equal to a given value form a normal subgroup of $A$.
###### `AutomorphismGroup(G): GrpPC -> GrpAuto`
Given a soluble group $G$ presented by a pc-presentation, this function returns the automorphism group of $G$ as a group of type `GrpAuto`.
###### `HasAttribute(A, "GenWeights"): GrpAuto, MonStgElt -> BoolElt, [ RngIntElt ]`
If the attribute `GenWeights` is defined for $A$ then the function returns `true`, and a sequence of integers. This integer sequence indicates where each generator lies in the normal series of $A$ corresponding to the action of the group on $G$ (as described at the beginning of the section). If the attribute is not set then the sequence is unassigned. The function call `AutomorphismGroup(G)`, where $G$ has type `GrpPC`, always returns an automorphism group with this attribute set. In this case the sequence may also be obtained by the short form ``A`GenWeights``.
###### `HasAttribute(A, "WeightSubgroupOrders"): GrpAuto, MonStgElt -> BoolElt, [ RngIntElt ]`
If the attribute `WeightSubgroupOrders` is defined for $A$ then the function returns `true`, and a sequence of integers. This sequence of integers gives the orders for the normal series of weight subgroups described at the beginning of the section. If the attribute is not set then the sequence is unassigned. The function call `AutomorphismGroup(G)`, where $G$ has type `GrpPC`, always returns an automorphism group with this attribute set. In this case the sequence may also be obtained by the short form ``A`WeightSubgroupOrders``.
###### `Example: Automorphism Group via Lifting (ex-29a2d6)`
An example using `AutomorphismGroup` and some related features. We build a group based on the structure of a finite field (multiplicative group acting on the additive group) and then compute its automorphism group. First, we set up the field.
```magma
> E := GF(2);
> F := GF(8);
> V,phi := VectorSpace(F,E);
> d := Dimension(V);
> x := PrimitiveElement(F);
```
Then, define a pc-group to act and define the action based on the multiplication in the field. Compute the matrix by mapping the vectors back to the field, multiplying by x, and then recording the result.
```magma
> C := CyclicGroup(GrpPC,Order(x));
> MR := MatrixRing(E, d);
> s := [];
> for i := 1 to d do
> y := ((V.i)@@phi)*x;
> s cat:= Eltseq(y);
> end for;
```
Turn the sequence of image components into a matrix and use the matrix to create a C-module. Then use that module to create the split extension.
```magma
> t := MR!s;
> M := GModule(C,[t]);
> G := Extension(M,C);
> G;
GrpPC : G of order 56 = 2^3 * 7
PC-Relations:
G.1^7 = Id(G),
G.2^2 = Id(G),
G.3^2 = Id(G),
G.4^2 = Id(G),
G.2^G.1 = G.3,
G.3^G.1 = G.4,
G.4^G.1 = G.2 * G.3
```
Then we can compute the automorphism group of $G$.
```magma
> A := AutomorphismGroup(G: Algorithm := "Default");
> A;
A group of automorphisms of GrpPC : G
Generators:
Automorphism of GrpPC : G which maps:
G.1 |--> G.1^2
G.2 |--> G.3 * G.4
G.3 |--> G.2 * G.4
G.4 |--> G.3
Automorphism of GrpPC : G which maps:
G.1 |--> G.1
G.2 |--> G.2 * G.3
G.3 |--> G.3 * G.4
G.4 |--> G.2 * G.3 * G.4
Automorphism of GrpPC : G which maps:
G.1 |--> G.1 * G.2 * G.3
G.2 |--> G.2
G.3 |--> G.3
G.4 |--> G.4
Automorphism of GrpPC : G which maps:
G.1 |--> G.1 * G.3 * G.4
G.2 |--> G.2
G.3 |--> G.3
G.4 |--> G.4
Automorphism of GrpPC : G which maps:
G.1 |--> G.1 * G.4
G.2 |--> G.2
G.3 |--> G.3
G.4 |--> G.4
> [Order(x):x in Generators(A)];
[ 3, 2, 7, 2, 2 ]
```
Next, we can use the automorphisms to create an extension of $G$.
```magma
> b := A.1;
> Order(b);
3
> tau := homG|[b(G.i):i in [1..NPCgens(G)]]>;
> D := CyclicGroup(GrpPC,Order(b));
> K := Extension(G,D,[tau]);
> K;
GrpPC : K of order 168 = 2^3 * 3 * 7
PC-Relations:
K.1^3 = Id(K),
K.2^7 = Id(K),
K.3^2 = Id(K),
K.4^2 = Id(K),
K.5^2 = Id(K),
K.2^K.1 = K.2^2,
K.3^K.1 = K.4 * K.5,
K.3^K.2 = K.4,
K.4^K.1 = K.3 * K.5,
K.4^K.2 = K.5,
K.5^K.1 = K.4,
K.5^K.2 = K.3 * K.4
> #Classes(K);
8
```
Finally, we examine information about the weight subgroups. We list only the orders of the terms of the characteristic series in $G$ in order to save space.
```magma
> [Order(H): H in A`CharacteristicSeries];
[ 56, 8, 1 ]
> A`GenWeights;
[ 1, 3, 4, 4, 4 ]
> A`WeightSubgroupOrders;
[ 168, 56, 56, 8 ]
```
##### Lifting from the Automorphism Group of a Sylow $p$-subgroup
The algorithm developed by D. Howden [[How12](https://docs.magma-maths.org/references.md#cite-howden-thesis)] follows a different strategy to the Smith-Slattery lifting approach. Given a soluble group $G$, the algorithm determines a suitable Sylow $p$-subgroup $P$ of $G$, and uses the automorphism group of $P$ (using the algorithm for $p$-groups detailed below) to construct the automorphism group of $G$. In cases where the automorphism group is soluble, the algorithm automatically constructs a pc-representation for it. Solubility of the returned group can then be tested via the `IsSoluble` intrinsic. The pc-representation obtained using the `PCGroup` intrinsic, and pc-generators (as automorphism maps) via the `PCGenerators` intrinsic. In some cases where the automorphism group is not soluble, the algorithm will construct a permutation representation during its construction. A group of type `GrpAuto` is returned. Details of the computation can be seen by setting the verbose flag `AutomorphismGroupSolubleGroup` to 1. A variation of this algorithm can be used for isomorphism testing.
###### `AutomorphismGroupSolubleGroup(G: parameters): GrpPC -> GrpAuto`
```magma
p: [RngIntElt] Default: 1
```
Given a soluble group $G$ presented by a pc-presentation, this function returns the automorphism group of $G$ as a group of type GrpAuto.
A prime $p$ dividing the order of $G$. The automorphism group of the Sylow $p$-subgroup is then used to construct the automorphism group of $G$. If the $p$-core of $G$ is trivial then an error is given. The default value of $p = 1$ indicates that the algorithm should take $p$ to be the prime giving the largest Sylow $p$-subgroup of $G$.
###### `IsIsomorphicSolubleGroup(G, H: parameters): GrpPC, GrpPC -> BoolElt, Map`
```magma
p: [RngIntElt] Default: 1
```
Returns `true` if the soluble groups $G$, $H$ presented by pc-presentations, are isomorphic, and `false` otherwise. Where the groups are isomorphic, a mapping $G\to H$ is also returned.
A prime $p$ dividing the order of $G$ (assuming that the orders of $G$ and $H$ are the same). The algorithm then tests Sylow $p$-subgroups of $G$ and $H$ for isomorphism and attempts to extend these isomorphisms to an isomorphism $G\to H$. If the $p$-cores of $G$ and $H$ are trivial then an error is given. The default value of $p = 1$ indicates that the algorithm should take $p$ to be the prime giving the largest Sylow $p$-subgroup of $G$.
###### `Example: Automorphisms of a Soluble Group (ex-249c9b)`
An example using `AutomorphismGroupSolubleGroup` and some related features. We use a group from the `solgps` library.
```magma
> load solgps;
> G := G10();
> FactoredOrder(G);
[ <2, 18>, <7, 4> ]
> time A := AutomorphismGroupSolubleGroup(G);
Time: 18.220
> time R_A, phi_A := PCGroup(A);
Time: 0.000
> FactoredOrder(R_A);
[ <2, 20>, <3, 2>, <7, 6> ]
```
#### $p$-group
For a description of the algorithm used to construct the automorphism group of a $p$-group, see [[ELGO02](https://docs.magma-maths.org/references.md#cite-elo-auts)].
While it is difficult to state very firm guidelines for the performance of the algorithm, our experience suggests that it has most difficulty in constructing automorphism groups of $p$-groups of “large” Frattini rank (say rank larger than about 6) and $p$-class 2. If the group has larger $p$-class, then it usually has more characteristic structure and the algorithm exploits this. The *order* of a group is *not* a useful guide to the difficulty of the computation.
`SetVerbose ("AutomorphismGroup", 1)` provides information on the progress of the algorithm.
##### `AutomorphismGroup(G: parameters): GrpPC -> GrpAuto`
```magma
CharacteristicSubgroups: [GrpPC] Default: []
```
The group $G$ is a $p$-group described by a pc-presentation. The function returns the automorphism group of $G$ as a group of type `GrpAuto`.
A list of known characteristic subgroups of $G$; these may improve the efficiency of the construction. Note that the algorithm simply accepts that the supplied subgroups are fixed under the action of the automorphism group; it does *not* verify that they are in fact characteristic.
##### `Example: Automorphism Group of a p-Group (ex-f1bbe5)`
```magma
> G := SmallGroup (64, 78);
> A := AutomorphismGroup (G);
> #A;
1024
> A.1;
Automorphism of GrpPC : G which maps:
G.1 |--> G.1
G.2 |--> G.2
G.3 |--> G.1 * G.3
G.4 |--> G.4
G.5 |--> G.5
G.6 |--> G.4 * G.6
> Order (A.1);
4
> a := A.1^2; [a (G.i): i in [1..6]];
[ G.1, G.2, G.3 * G.5, G.4, G.5, G.6 ]
```
##### `OrderAutomorphismGroupAbelianPGroup(A): SeqEnum -> RngIntElt`
Order of automorphism group of abelian $p$-group $G$ where $A = [a_1, a_2, \ldots]$ and $G = C_{a_1} \times C_{a_2} \times \ldots$.
##### `Example: Subgroups of an Abelian p-Group (ex-c99f0c)`
Subgroups of $C_4 \times C_8 \times C_{64}$.
```magma
> NumberOfSubgroupsAbelianPGroup ([4, 8, 64]);
[ 7, 35, 91, 139, 171, 171, 139, 91, 35, 7, 1 ]
```
Hence, for example, there are 7 subgroups of order 2 and 139 subgroups of order $2^4$.
```magma
> OrderAutomorphismGroupAbelianPGroup ([4, 8, 64]);
4194304
```
#### Isomorphism and Standard Presentations
The `pQuotient` command returns a power-conjugate presentation for a given $p$-group but this presentation depends on the user-supplied description of the group. The Standard Presentation algorithm computes a “canonical” presentation for the $p$-group, which is independent of the user-supplied description. For a description of this algorithm, see [[OBr94](https://docs.magma-maths.org/references.md#cite-obrien-isom)]. The canonical or *standard* presentation of a given $p$-group is the power-conjugate presentation obtained when a description of the group is computed using the default implementation of the $p$-group generation algorithm. Hence, two groups in the same isomorphism class have identical standard presentations. Given two $p$-groups, if their standard presentations are identical, then the groups are isomorphic, otherwise they are not. Hence to decide whether two groups are isomorphic, we can first construct the standard presentation of each using the `StandardPresentation` function and then compare these presentations using the `IsIdenticalPresentation` function.
While it is difficult to state very firm guidelines for the performance of the algorithm, our experience suggests that the difficulty of deciding isomorphism between $p$-groups is governed by their Frattini rank and is most practical for $p$-groups of rank at most 5. The *order* of a group is *not* a useful guide to the difficulty of the computation.
`SetVerbose ("Standard", 1)` will provide information on the progress of the algorithm.
##### `StandardPresentation(G): GrpPC -> GrpPC, Map`
##### `StandardPresentation(G: parameters): GrpPC -> GrpAuto`
```magma
StartClass: RngIntElt Default: 1
```
The group $G$ is a $p$-group presented by an arbitrary pc-presentation. The group $H$ defined by its standard presentation is returned together with a map from $G$ to $H$.
If `StartClass` is $k$, then use `pQuotient` to construct the class $k - 1$ $p$-quotient of $G$ and standardize the presentation only from class $k$ onwards.
##### `IsIdenticalPresentation(G, H): GrpPC, GrpPC -> BoolElt`
Returns `true` if $G$ and $H$ have identical presentations, `false` otherwise.
##### `IsIsomorphic(G, H): GrpPC, GrpPC -> BoolElt, Map, GrpPC`
The function returns `true` if the $p$-groups $G$ and $H$ are isomorphic, `false` otherwise. It constructs their standard presentations class by class, and checks for equality. If they are isomorphic, it also returns an isomorphism from $G$ to $H$ and the isomorphism class representative.
##### `Example: Isomorphism of p-Quotients (ex-75ee54)`
In the next two examples, we investigate whether particular $p$-quotients of fp-groups are isomorphic.
```magma
> F := FreeGroup(3);
> G := quo< F | x*y^2*x^-1=y^-2, y*x^2*y^-1=x^-2, x^2=t^2, y^2=(t^-1*x)^2,
> t*(x*y)^2=(x*y)^2*t >;
> Q1 := pQuotient(G, 2, 3: Print := 1);
Lower exponent-2 central series for G
Group: G to lower exponent-2 central class 1 has order 2^3
Group: G to lower exponent-2 central class 2 has order 2^7
Group: G to lower exponent-2 central class 3 has order 2^11
> H := quo< F | x*y^2*x^-1=y^-2, y*x^2*y^-1=x^-2, x^2=t^2*(x*y)^2,
> y^2=(t^-1*x)^2, t*(x*y)^2=(x*y)^2*t >;
> Q2 := pQuotient(H, 2, 3: Print := 1);
Lower exponent-2 central series for H
Group: H to lower exponent-2 central class 1 has order 2^3
Group: H to lower exponent-2 central class 2 has order 2^7
Group: H to lower exponent-2 central class 3 has order 2^11
```
Now check whether the class 3 2-quotients are isomorphic.
```magma
> IsIsomorphic(Q1, Q2);
false
```
In the next example, we construct an explicit isomorphism between two 5-groups.
```magma
> F := Group;
> G := pQuotient (F, 5, 6 : Print := 1);
Lower exponent-5 central series for F
Group: F to lower exponent-5 central class 1 has order 5^2
Group: F to lower exponent-5 central class 2 has order 5^3
Group: F to lower exponent-5 central class 3 has order 5^4
Group: F to lower exponent-5 central class 4 has order 5^5
Group: F to lower exponent-5 central class 5 has order 5^7
Group: F to lower exponent-5 central class 6 has order 5^8
> G;
GrpPC : G of order 390625 = 5^8
PC-Relations:
G.2^G.1 = G.2 * G.3,
G.3^G.1 = G.3 * G.4,
G.3^G.2 = G.3 * G.6 * G.7^4 * G.8^4,
G.4^G.1 = G.4 * G.5,
G.4^G.2 = G.4 * G.7 * G.8,
G.4^G.3 = G.4 * G.7^4 * G.8,
G.5^G.1 = G.5 * G.6,
G.5^G.2 = G.5 * G.7,
G.5^G.3 = G.5 * G.8^2,
G.6^G.2 = G.6 * G.8,
G.7^G.1 = G.7 * G.8^3
> K := Group;
> H := pQuotient (K, 5, 6 : Print := 1);
Lower exponent-5 central series for K
Group: K to lower exponent-5 central class 1 has order 5^2
Group: K to lower exponent-5 central class 2 has order 5^3
Group: K to lower exponent-5 central class 3 has order 5^4
Group: K to lower exponent-5 central class 4 has order 5^5
Group: K to lower exponent-5 central class 5 has order 5^7
Group: K to lower exponent-5 central class 6 has order 5^8
> H;
GrpPC : H of order 390625 = 5^8
PC-Relations:
H.2^H.1 = H.2 * H.3,
H.3^H.1 = H.3 * H.4,
H.3^H.2 = H.3 * H.6^2 * H.7^2 * H.8^2,
H.4^H.1 = H.4 * H.5,
H.4^H.2 = H.4 * H.7,
H.4^H.3 = H.4 * H.7^4 * H.8,
H.5^H.1 = H.5 * H.6,
H.5^H.2 = H.5 * H.7,
H.5^H.3 = H.5 * H.8^2,
H.6^H.2 = H.6 * H.8,
H.7^H.1 = H.7 * H.8^3
> flag, phi := IsIsomorphic (G, H);
> flag;
true
> for g in PCGenerators (G) do print g, "--->", phi (g); end for;
G.1 ---> H.1
G.2 ---> H.2^3 * H.4^3 * H.5^3 * H.6^2 * H.7^4 * H.8^3
G.3 ---> H.3^3 * H.5^3 * H.6^4 * H.8^3
G.4 ---> H.4^3 * H.6^3 * H.7^2 * H.8^3
G.5 ---> H.5^3 * H.8
G.6 ---> H.6^3
G.7 ---> H.7^4
G.8 ---> H.8^4
```
The functions `IsIsomorphic` and `StandardPresentation` are expensive. Here we have a list of groups and we want to find any isomorphisms among the collection. Rather than repeatedly applying `IsIsomorphic`, we first construct and store standard presentations for each group in the sequence, and then quickly compare these using `IsIdenticalPresentation`.
```magma
> F := FreeGroup (2);
> p := 7;
> Q := [];
> for k := 1 to p - 1 do
> G := quo< F | a^p = (b, a, a), b^p = a^(k*p), (b, a, b)>;
> H := pQuotient (G, p, 10);
> Q[k] := StandardPresentation (H);
> end for;
```
Now run over the list of standard presentations and check for equality.
```magma
> for i in [2..p - 1] do
> for j in [1.. i - 1] do
> if IsIdenticalPresentation (Q[i], Q[j]) then
> print "Standard Presentations ", i, " and ", j, " are identical";
> end if;
> end for;
> end for;
Standard Presentations 2 and 1 are identical
Standard Presentations 4 and 1 are identical
Standard Presentations 4 and 2 are identical
Standard Presentations 5 and 3 are identical
Standard Presentations 6 and 3 are identical
Standard Presentations 6 and 5 are identical
```
### Generating $p$-groups
The $p$-central series of a group $G$ is the descending sequence of subgroups
$$
G= P_{0}(G) \geq \ldots \geq P_{i-1}(G) \geq P_i(G) \geq \ldots \geq
$$
where $P_i(G)=[P_{i-1}(G),G]P_{i-1}(G)^p$ for $i\geq 1$.
If $P_c(G)=1$ and $c$ is the smallest such integer then $G$ has $p$*-class* $c$. A group with $p$-class $c$ is nilpotent and has nilpotency class at most $c$.
Let $G$ be a finite $p$-group with Frattini rank $d$ and class $c$. A group $H$ is a *descendant* of $G$ if $H$ has Frattini rank $d$ and the quotient $H/P_c(H)$ is isomorphic to $G$. A group is an *immediate descendant* of $G$ if it is a descendant of $G$ and has class $c+1$.
The $p$-group generation algorithm allows the construction of (immediate) descendants of a $p$-group. For a description of this algorithm, see [[New77](https://docs.magma-maths.org/references.md#cite-newman-pgrp-gen), [OBr90](https://docs.magma-maths.org/references.md#cite-obrien-pgroup)].
`SetVerbose ("GeneratepGroups", 1)` will provide information on the progress of the algorithm.
#### `GeneratepGroups(p, d, c : parameters): RngIntElt, RngIntElt, RngIntElt -> [GrpPC], RngIntElt`
```magma
Exponent : RngIntElt Default: 0
OrderBound: RngIntElt Default: 0
StepSizes : [RngIntElt] Default: []
All : BoolElt Default: true
```
Generate all $d$-generator $p$-class at most $c$ $p$-groups.
All groups constructed satisfy the supplied exponent.
Given `OrderBound := n`, all groups constructed have order at most $p^n$.
Construct descendants of order $p^{(n + s)}$ of a group of order $p^n$ only for $s$ in `StepSizes`.
If `true`, return all groups. Otherwise, return only the capable groups (those which have descendants).
#### `Descendants(G : parameters): GrpPC -> [GrpPC], RngIntElt`
#### `Descendants(G, c : parameters): GrpPC, RngIntElt -> [GrpPC], RngIntElt`
Construct descendants of $G$ having $p$-class at most $c$; if $c$ is not supplied, it is assumed to be one larger than the $p$-class of $G$. This function supports the same variable arguments as `GeneratepGroups`.
#### `Example: Descendants of a 2-Group (ex-3d4202)`
```magma
> G := DihedralGroup(GrpPC, 16);
> T := Descendants (G, 8);
> #T;
12
> H := T[5];
> H;
GrpPC : H of order 128 = 2^7
PC-Relations:
H.1^2 = H.7,
H.2^2 = H.3 * H.4,
H.3^2 = H.4 * H.5,
H.4^2 = H.5 * H.6,
H.5^2 = H.6 * H.7,
H.6^2 = H.7,
H.2^H.1 = H.2 * H.3,
H.3^H.1 = H.3 * H.4,
H.4^H.1 = H.4 * H.5,
H.5^H.1 = H.5 * H.6,
H.6^H.1 = H.6 * H.7
```
#### `Example: 2-Generator Groups of Exponent 4 (ex-e130f7)`
What is the soluble length of a 2-generator group of exponent 4? We construct the 2-generator 2-groups having exponent 4.
```magma
> T := GeneratepGroups(2, 2, 10: Exponent := 4);
> "The number of 2-generator exponent 4 groups is ", # T;
The number of 2-generator exponent 4 groups is 26
```
What are their soluble lengths?
```magma
> for i := 1 to #T do
> "Group ", i, " has soluble length ", DerivedLength (T[i]);
> end for;
Group 1 has soluble length 1
Group 2 has soluble length 2
Group 3 has soluble length 2
Group 4 has soluble length 1
Group 5 has soluble length 2
Group 6 has soluble length 2
Group 7 has soluble length 2
Group 8 has soluble length 2
Group 9 has soluble length 2
Group 10 has soluble length 2
Group 11 has soluble length 2
Group 12 has soluble length 2
Group 13 has soluble length 2
Group 14 has soluble length 2
Group 15 has soluble length 2
Group 16 has soluble length 2
Group 17 has soluble length 2
Group 18 has soluble length 2
Group 19 has soluble length 2
Group 20 has soluble length 2
Group 21 has soluble length 3
Group 22 has soluble length 3
Group 23 has soluble length 3
Group 24 has soluble length 3
Group 25 has soluble length 3
Group 26 has soluble length 3
```
#### `Example: 2-Generator 3-Groups of Abundance Zero (ex-4efc58)`
Can we find all 2-generator 3-groups of abundance zero? Such groups have order at most $3^5$. First, we define a function which checks the number of conjugacy classes of a group (to determine abundance).
```magma
> IsGoodGroup := function(G, k)
>
> ncl := # Classes(G);
>
> O := FactoredOrder(G);
> p := O[1][1];
> m := O[1][2];
> n := Floor(m / 2);
> e := m - n * 2;
> Desired := n * (p^2 - 1) + p^e + k * (p - 1) * (p^2 - 1);
>
> return (Desired eq ncl);
>
> end function;
```
Then, we generate the potential candidates and check each.
```magma
> a := GeneratepGroups (3, 2, 4 : OrderBound := 5);
> #a;
42
>
> for i := 1 to #a do
> G := a[i];
> if IsGoodGroup(G, 0) then
> "Group ", i, " of order ", Order(G), " has abundance 0";
> end if;
> end for;
Group 1 of order 9 has abundance 0
Group 3 of order 27 has abundance 0
Group 4 of order 27 has abundance 0
Group 11 of order 81 has abundance 0
Group 12 of order 81 has abundance 0
Group 13 of order 81 has abundance 0
Group 14 of order 81 has abundance 0
Group 40 of order 243 has abundance 0
Group 41 of order 243 has abundance 0
Group 42 of order 243 has abundance 0
```
#### `ClassTwo(p, d : parameters): RngIntElt, RngIntElt -> SeqEnum`
#### `ClassTwo(p, d, Step : parameters): RngIntElt, RngIntElt, SeqEnum -> SeqEnum`
#### `ClassTwo(p, d, s : parameters): RngIntElt, RngIntElt, RngIntElt -> RngIntElt`
```magma
Exponent: RngIntElt Default: 0
```
Count the $d$-generator $p$-groups of $p$-class 2. If $s$ or $Step$ is supplied, then count only those of order $p^{(d + s)}$ or $p^{(d + m)}$ for $m \in Step$. In the first two invocations, the sequence returns a sequence of length $d \choose 2$, whose $m$-th entry is the number of groups of $p^{(d + m)}$. (Some additional entries may be deduced on the basis of duality.) The last invocation returns the number of groups of $p^{(d + s)}$. For details of the algorithm used see [[EO99](https://docs.magma-maths.org/references.md#cite-eo-enum)].
If `Exponent` is `true`, count those groups which have exponent $p$. The directive `SetVerbose ("ClassTwo", 1)` will provide information on the progress of the algorithm.
#### `Example: Counting p-Class 2 Groups (ex-6ce143)`
Count the number of 3-generator p-class 2 5-groups.
```magma
> ClassTwo(5, 3);
[ 4, 19, 42, 19, 4, 1 ]
```
For example, the number of 3-generator 5-groups of order $5^6$ and $p$-class 2 is precisely 42.
Count the number of 4-generator $p$-class 2 5-groups of order $5^7$.
```magma
> ClassTwo(5, 4, 3);
6598
```
### Representation Theory
Chapter [Characters of Finite Groups](https://docs.magma-maths.org/RepresentationTheory/CharactersOfFiniteGroups/index-characters-of-finite-groups.md#chapchtr) on characters describes many functions for computing with partial character tables or individual characters.
#### `CharacterDegrees(G): GrpPC -> [ Tup ]`
#### `CharacterDegrees(G, z, p): GrpPC, GrpPCElt, RngIntElt -> [ Tup ]`
Given a finite pc-group $G$, return the sequence $[\langle d_1,c_1\rangle, \langle d_2,c_2\rangle, \ldots]$, where $c_i$ is the number of irreducible characters of $G$ having degree $d_i$. For details of the algorithm see Conlon [[Con90b](https://docs.magma-maths.org/references.md#cite-conlon-degrees)].
The second form requires $z$ to be a central element of $G$ and $p$ to be a prime or zero. The sequence returned enumerates the number of absolutely irreducible characters of $G$ in characteristic $p$, lying over some faithful linear character of $\langle z\rangle$.
#### `CharacterDegrees(G): GrpFin -> [ Tup ]`
Given a finite $p$-group $G$, return the sequence $[\langle d_1,c_1\rangle, \langle d_2,c_2\rangle, \ldots]$, where $c_i$ is the number of irreducible characters of $G$ having degree $d_i$. For details of the algorithm see [[Sla86](https://docs.magma-maths.org/references.md#cite-slat-degs)].
#### `CharacterDegreesPGroup(G): GrpFin -> [ RngIntElt ]`
Given a finite $p$-group $G$, return the sequence $[C_0, C_1, \ldots]$, where $C_i$ is the number of irreducible characters of $G$ having degree $p^i$. For details of the algorithm see [[Sla86](https://docs.magma-maths.org/references.md#cite-slat-degs)].
#### `CharacterTable(G: parameters): GrpPC -> TabChtr`
```magma
Al : MonStgElt Default: "Default"
DSSizeLimit: RngIntElt Default: 10^4
```
Construct the table of ordinary irreducible characters for the group $G$.
This parameter controls the algorithm used. The string `"DS"` forces use of the Dixon-Schneider algorithm. The string `"IR"` forces the use of Unger’s induction/reduction algorithm [[Ung06a](https://docs.magma-maths.org/references.md#cite-chtr-table-unger)]. The `"Default"` algorithm is to use Dixon-Schneider for groups of order $\le 5000$ and Unger’s algorithm for larger groups. This may change in future.
When the default algorithm is selected, a positive value $n$ for `DSSizeLimit` means that before using Unger’s algorithm, the full character space is split by some passes of Dixon-Schneider, restricted to using class matrices corresponding to conjugacy classes with size at most $n$.
#### `CharacterTableConlon(G): GrpPC -> [ AlgChtrElt ]`
Given a finite $p$-group $G$, return the character table of $G$. The algorithm is due to Conlon, as described in [[Con90a](https://docs.magma-maths.org/references.md#cite-conlon-chtrs)].
#### `GModule(G, M): GrpPC, AlgMat -> ModAlg`
The $G$-module for the action of $G$ on the vector space defined by the matrix ring $M$.
#### `GModule(G, A): GrpPC, GrpPC -> ModAlg, Map`
A $KG$-module $M$ corresponding to the action of the group $G$ on the elementary abelian subgroup $A$ of $G$ is constructed. The map from $A$ to the vector space underlying $M$ is also returned.
#### `GModule(G, A, B): GrpPC, GrpPC, GrpPC -> ModAlg, Map`
A $KG$-module $M$ corresponding to the action of the group $G$ on the elementary abelian section $A/B$ of $G$ is constructed. The map from $A$ to the vector space underlying $M$ is also returned.
#### `AbsolutelyIrreducibleRepresentationsSchur(G, k: parameters): GrpPC, Rng -> List[Map]`
#### `AbsolutelyIrreducibleModulesSchur(G, k: parameters): GrpPC, Rng -> List[GModule]`
#### `AbsolutelyIrreducibleRepresentationsSchur(G, k, i: parameters): GrpPC, Rng, RngIntElt -> List[Map]`
#### `AbsolutelyIrreducibleModulesSchur(G, k, i: parameters): GrpPC, Rng, RngIntElt -> List[GModule]`
#### `AbsolutelyIrreducibleRepresentationsSchur(G, k, L: parameters): GrpPC, Rng, List[Map] -> List[Map]`
#### `AbsolutelyIrreducibleModulesSchur(G, k, L: parameters): GrpPC, Rng, List[GModule] -> List[GModule]`
#### `AbsolutelyIrreducibleRepresentationsSchur(G, k, L, i: parameters): GrpPC, Rng, List[Map], RngIntElt -> List[Map]`
#### `AbsolutelyIrreducibleModulesSchur(G, k, L, i: parameters): GrpPC, Rng, RngIntElt -> List[GModule]`
```magma
Process : BoolElt Default: true
GaloisAction : MonStgElt Default: "Yes"
MaxDimension : RngIntElt Default:
ExactDimension: SetEnum Default:
```
Compute the absolutely irreducible representations of the group $G$ over appropriate extensions or sub-fields of the given field $k$. The representations returned are inequivalent and consist of all distinct representations, subject to the conditions imposed. The field $k$ may be a finite field, the rationals, or a cyclotomic field. In the case when $k$ is a finite field, the Glasby-Howlett algorithm is used to determine the minimal field over which a representation may be realised. If $k$ has characteristic 0, the field over which a representation is realised may not be minimal.
The representations are found using Schur’s method of climbing the composition series for $G$ defined by the pc-presentation. If the argument $i$ is given then the algorithm will calculate only representations of the $i$th subgroup of the composition series.
The “Representations” function returns a list of homomorphisms $\rho : G \to GL(n, K)$, where $K$ is a field compatible with $k$. The “Modules” version returns an equivalent list of $G$-modules.
If the parameter `Process` is set true then the list is a list of pairs comprising an integer and a representation. This list or any sublist of it is a suitable value for the argument $L$ in the last versions of the function, and in this case only the representations in $L$ will be extended up the series. This allows the user to inspect the representations produced along the way and cull any that are uninteresting.
Possible values are `"Yes"`, `"No"`, and `"Relative"`. The default is `"Yes"` for intermediate levels and `"No"` for the whole group. The value `"Yes"` means that it only lists one representation from each orbit of the action of the absolute Galois group $Gal(K/\text{primefield(}K\text{)})$. Setting this parameter to `"No"` turns this reduction off (thus listing all inequivalent representations), while setting it to `"Relative"` uses the group $Gal(K/k)$.
Restrict the representations to those of dimension $\le$ `MaxDimension`. The default is no restriction.
If `ExactDimension` is assigned a set $S$ of positive integers, attention is restricted to representations having dimensions lying in the set $S$. The default is equivalent to taking the set of all positive integers.
If both `MaxDimension` and `ExactDimension` are assigned values, then representations having dimensions that are either bounded by `MaxDimension` or contained in `ExactDimension` are produced.
#### `IrreducibleRepresentationsSchur(G, k: parameters): GrpPC, Rng -> List[Map]`
#### `IrreducibleModulesSchur(G, k: parameters): GrpPC, Rng -> List[GModule]`
#### `IrreducibleRepresentationsSchur(G, k, i: parameters): GrpPC, Rng, RngIntElt -> List[Map]`
#### `IrreducibleModulesSchur(G, k, i: parameters): GrpPC, Rng, RngIntElt -> List[GModule]`
#### `IrreducibleRepresentationsSchur(G, k, L: parameters): GrpPC, Rng, List[Map] -> List[Map]`
#### `IrreducibleModulesSchur(G, k, L: parameters): GrpPC, Rng, List[GModule] -> List[GModule]`
#### `IrreducibleRepresentationsSchur(G, k, L, i: parameters): GrpPC, Rng, List[Map], RngIntElt -> List[Map]`
#### `IrreducibleModulesSchur(G, k, L, i: parameters): GrpPC, Rng, List[GModule], RngIntElt -> List[GModule]`
Compute irreducible representations of $G$ over the given field $k$. All arguments and parameters are as for the absolutely irreducible case.
The computation proceeds by first computing the absolutely irreducible representations subject to the given parameters, then rewriting over the field $k$, with a consequent change of dimension of the representation.
#### `Example: Representations of the Dihedral Group of Order 20 (ex-ca921e)`
We compute representations of the dihedral group of order 20.
```magma
> G := DihedralGroup(GrpPC, 10);
> FactoredOrder(G);
[ <2, 2>, <5, 1> ]
```
First some modular representations with characteristic 2.
```magma
> r := IrreducibleModulesSchur(G, GF(2));
> r;
[*
GModule of dimension 1 over GF(2),
GModule of dimension 4 over GF(2)
*]
> r := AbsolutelyIrreducibleModulesSchur(G, GF(2));
> r;
[*
GModule of dimension 1 over GF(2),
GModule of dimension 2 over GF(2^2),
GModule of dimension 2 over GF(2^2)
*]
> r := AbsolutelyIrreducibleModulesSchur(G, GF(2) : GaloisAction:="Yes");
> r;
[*
GModule of dimension 1 over GF(2),
GModule of dimension 2 over GF(2^2)
*]
```
The irreducible representation of dimension 4 is not absolutely irreducible, as over $GF(4)$ it splits into two Galois-equivalent representations.
Getting irreducible representations over the complex field presents no problem, despite not being able to use the complex field as an argument to the function call. We could specify the field to be the cyclotomic field with degree equal to Exponent(G), but it is preferable to ask for absolutely irreducible representations over the rationals.
```magma
> r := AbsolutelyIrreducibleRepresentationsSchur(G, Rationals());
> r;
[*
Mapping from: GrpPC: G to GL(1, RationalField()),
Mapping from: GrpPC: G to GL(1, RationalField()),
Mapping from: GrpPC: G to GL(1, RationalField()),
Mapping from: GrpPC: G to GL(1, RationalField()),
Mapping from: GrpPC: G to GL(2, CyclotomicField(5)),
Mapping from: GrpPC: G to GL(2, CyclotomicField(5)),
Mapping from: GrpPC: G to GL(2, CyclotomicField(5)),
Mapping from: GrpPC: G to GL(2, CyclotomicField(5))
*]
> r[6](G.2);
[zeta_5^3 0]
[ 0 zeta_5^2]
```
### Central Extensions
We now describe functions to construct $H^2(G,U)$ for a finite soluble group $G$ and finite abelian group $U$ (a trivial $G$-module). We also present functions to construct central extensions of $U$ by $G$.
Denote by $Z^2(G,U)$ the abelian group of all cocycles from $G$ to $U$, under pointwise multiplication. The values $\psi(g,h)$ of $\psi \in Z^2(G, U)$ may be represented as a “cocyclic matrix” with entries in $U$.
If $\phi \from G \ar U$ is a set map with $\phi (1_G) = 1_U$, then there is a coboundary $\partial \phi \in Z^2(G,U)$ defined by $\partial \phi(g,h) = \phi(g) \phi (h) \phi(gh)^{-1}$. The group of all coboundaries from $G$ to $U$ is denoted $B^2(G,U)$, and we have $H^2(G,U) = Z^2(G,U)/B^2(G,U)$. Then $H^2(G,U)=I\times T$, where $I$ is the (faithful) image of $\operatorname{Ext}(G/G', U) \leq H^2(G/G', U)$ under inflation, and $T$ is the (faithful) image of $\Hom(H_2(G), U)$ under a certain transgression homomorphism. Here we provide functions which construct representatives for the elements in a generating set for each of these two factors.
For details of the theory and the algorithm used, see [[FO00](https://docs.magma-maths.org/references.md#cite-fo-centex)].
`SetVerbose ("Cocycle", 1)` will provide additional information on the calculations in the functions.
#### `ExtGenerators(G, U): GrpPC, GrpPC -> []`
Given a soluble group $G$ and an abelian group $U$ (both defined by pc-presentations) the function returns a sequence of tuples describing generators for $\operatorname{Ext}(G/G', U)$ as cocyclic matrices; the first entry in each tuple is a representative of a generator, the second is the order of the coset of the representative in $H^2(G, U)$.
#### `HomGenerators(G, U): GrpPC, GrpPC -> []`
Given a soluble group $G$ and an abelian group $U$ (both defined by pc-presentations) the function returns a sequence of tuples describing generators for $\Hom(H_2 (G), U)$ as cocyclic matrices; the first entry in each tuple is a representative of a generator, the second is the order of the coset of the representative in $H^2(G, U)$.
#### `ElementSequence(G): GrpPC -> SeqEnum`
For a soluble group $G$, the function returns an indexed set of elements of $G$ listed in the order used by `ExtGenerators` and `HomGenerators`.
#### `RepresentativeCocycles(G, U, Ext, Hom): GrpPC, GrpPC, [AlgMatElt], [AlgMatElt] -> [AlgMatElt]`
Let $G$ be a soluble group $G$ and $U$ be an abelian group both defined by pc-presentations. Let $Ext$ and $Hom$ be the values returned by calling `ExtGenerators` and `HomGenerators` respectively. The function `RepresentativeCocycles` returns a complete and irredundant set of representatives for the elements of $H^2(G,U)$ as cocyclic matrices.
#### `CentralExtension(G, U, A): GrpPC, GrpPC, AlgMatElt -> GrpPC`
Let $G$ be a soluble group $G$ and $U$ be an abelian group, both defined by pc-presentations. Further, let $A$ be a cocyclic matrix (as determined by the function `RepresentativeCocycles`). Then, this function returns the central extension of $U$ by $G$ determined by the cocyclic matrix $A$.
#### `CentralExtensions(G, U, Q): GrpPC, GrpPC, [AlgMatElt] -> [GrpPC]`
If $G$ is a soluble group $G$ and $U$ is an abelian group, both defined by pc-presentations, and $Q$ is a sequence of cocyclic matrices (as determined by the function `RepresentativeCocycles`), this function returns the corresponding sequence of central extension of $U$ by $G$ determined by the sequence of cocyclic matrices $A$. Note that the central extensions thereby constructed need not be mutually non-isomorphic.
#### `CentralExtensionProcess(G, U): GrpPC, GrpPC -> Proc`
Given a soluble group $G$ and an abelian group $U$ (both defined by pc-presentations) the function creates a process $P$ for central extensions of $U$ by $G$. Note that the list of central extensions constructed by this process will contain all isomorphism types but the extensions need not be mutually non-isomorphic.
#### `NextExtension(~P): Rec -> GrpPC`
Given a central extension process $P$, construct the next central extension determined by $P$.
#### `IsEmpty(P): Rec -> BoolElt`
Return `true` if all central extensions determined by the process $P$ have been constructed; otherwise return `false`.
#### `Example: Central Extensions of a Dihedral Group (ex-b4d774)`
We compute the abelian invariants of $H^2 (D_4, C_2)$.
```magma
> G := DihedralGroup(GrpPC, 4);
> U := AbelianGroup(GrpPC, [2]);
>
> Ext := ExtGenerators(G, U);
> Ext[1];
<[Id(U) Id(U) Id(U) Id(U) Id(U) Id(U) Id(U) Id(U)]
[Id(U) Id(U) Id(U) Id(U) Id(U) Id(U) Id(U) Id(U)]
[Id(U) Id(U) Id(U) Id(U) Id(U) Id(U) Id(U) Id(U)]
[Id(U) Id(U) Id(U) Id(U) Id(U) Id(U) Id(U) Id(U)]
[Id(U) Id(U) Id(U) Id(U) U.1 U.1 U.1 U.1]
[Id(U) Id(U) Id(U) Id(U) U.1 U.1 U.1 U.1]
[Id(U) Id(U) Id(U) Id(U) U.1 U.1 U.1 U.1]
[Id(U) Id(U) Id(U) Id(U) U.1 U.1 U.1 U.1], 2>,
>
> Hom := HomGenerators(G, U);
> Hom;
[
<[Id(U) Id(U) Id(U) Id(U) Id(U) Id(U) Id(U) Id(U)]
[Id(U) U.1 U.1 Id(U) Id(U) U.1 U.1 Id(U)]
[Id(U) Id(U) Id(U) Id(U) Id(U) Id(U) Id(U) Id(U)]
[Id(U) U.1 U.1 Id(U) Id(U) U.1 U.1 Id(U)]
[Id(U) Id(U) Id(U) U.1 Id(U) U.1 U.1 U.1]
[Id(U) U.1 Id(U) Id(U) U.1 U.1 Id(U) U.1]
[Id(U) Id(U) Id(U) U.1 Id(U) U.1 U.1 U.1]
[Id(U) U.1 Id(U) Id(U) U.1 U.1 Id(U) U.1], 2>
]
>
> AbelianInvariants(Ext, Hom);
[ 2, 2, 2 ]
```
We now compute the central extension of U by G determined by a single cocyclic matrix.
```magma
> A := RepresentativeCocycles(G, U, Ext, Hom);
> E := CentralExtension(G, U, A[2]);
> E;
GrpPC : E of order 16 = 2^4
PC-Relations:
E.1^2 = E.4,
E.2^2 = E.3 * E.4,
E.2^E.1 = E.2 * E.3
```
Alternatively we can build all central extensions of U by G.
```magma
> E := CentralExtensions(G, U, A);
> "Number of extensions is ", #E;
Number of extensions is 8
```
Next, we provide an example of using the central extension process. Firstly, we create the groups and initialize the process.
```magma
> G := SmallGroup(12, 5);
> U := AbelianGroup(GrpPC, [2, 3]);
> P := CentralExtensionProcess(G, U);
```
Now we run over the central extensions and count conjugacy classes.
```magma
> C := [];
> while IsEmpty(P) eq false do
> NextExtension(~P, ~E);
> Append(~C, #Classes (E));
> end while;
> "# conjugacy classes is ", C;
# conjugacy classes is [ 45, 72, 45, 72, 45, 72, 45, 72, 45, 72, 45,
72, 45, 72, 45, 72, 45, 72, 45, 72, 45, 72, 45, 72 ]
```
### Transfer Between Group Categories
#### Transfer to GrpPC
The `PolycyclicGroup`-constructor allows complete flexibility in defining a pc-group. However, it is often more convenient to have Magma compute a pc-presentation based on some other description of the group. The `PCGroup` function will produce a pc-presentation for a finite group in various categories such as [`GrpPerm`](https://docs.magma-maths.org/FiniteGroups/PermutationGroups/index-permutation-groups.md#chapgrpperm) and [`GrpMat`](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverGeneralRings/index-matrix-groups-over-general-rings.md#chapgrpmat). Converting from a [`GrpFP`](https://docs.magma-maths.org/FinitelyPresentedGroups/FPGroups/index-fpgroups.md#chapgrpfp) group is trickier, since the original group need not be finite. There are two functions provided to produce pc-presentations for certain quotients of finitely-presented groups. The `pQuotient` function constructs a pc-presentation for the largest $p$-group quotient having specified lower exponent-$p$ class. Similarly, `SolubleQuotient` will compute the largest soluble quotient subject to certain restrictions. Each of these functions also provides a homomorphism (isomorphism in the case of `PCGroup`) from the original group to the new pc-group. More information on each of the two quotient functions can be found in Chapter [Finitely Presented Groups](https://docs.magma-maths.org/FinitelyPresentedGroups/FPGroups/index-fpgroups.md#chapgrpfp).
##### `PCGroup(G): GrpPerm -> GrpPC, Map`
##### `PCGroup(G): GrpMat -> GrpPC, Map`
##### `PCGroup(G): GrpFP -> GrpPC`
A `GrpPC` representation of the group $G$ and the isomorphism.
##### `pQuotient(F, p, c : parameters): GrpFP, RngIntElt, RngIntElt -> GrpPC, Map`
```magma
Workspace : RngIntElt Default: 1000000
Metabelian: BoolElt Default: false
Exponent : RngIntElt Default: 0
Print : RngIntElt Default: 0
```
Given a finitely presented group $F$, a prime $p$, and a positive integer $c$, this function constructs a consistent power-conjugate presentation for the largest $p$-quotient $H$ of $F$ having lower exponent-$p$ class at most $c$. If $c$ is given as zero, then the limit 127 is placed on the class. The prime $p$ must be less than $65536$. The function returns both the $p$-quotient $H$ defined by a pc-presentation and the homomorphism from $F$ to $H$.
##### `SolubleQuotient(G): Grp -> GrpPC, Map`
##### `SolvableQuotient(G): Grp -> GrpPC, Map`
A `GrpPC` representation $P$ of the largest solvable quotient of $G$ and the homomorphism $\phi: G\rightarrow P$.
##### `Example: Pc-Presentation of a Matrix Group (ex-84bae2)`
We use `PCGroup` to produce a pc-presentation for a matrix group.
```magma
> GL := GeneralLinearGroup(4,GF(3));
> S3 := Sylow(GL,3);
> P := PCGroup(S3);
> P;
GrpPC : P of order 729 = 3^6
PC-Relations:
P.2^P.1 = P.2 * P.4^2,
P.3^P.1 = P.3 * P.5^2,
P.3^P.2 = P.3 * P.6^2,
P.5^P.2 = P.4 * P.5,
P.6^P.1 = P.4 * P.6
```
#### Transfer from GrpPC
Given a pc-group, it is straight-forward to convert it to a [`GrpFP`](https://docs.magma-maths.org/FinitelyPresentedGroups/FPGroups/index-fpgroups.md#chapgrpfp) or [`GrpGPC`](https://docs.magma-maths.org/FinitelyPresentedGroups/PolycyclicGroups/index-polycyclic-groups.md#chapgrpgpc) representation by using the appropriate transfer function. If one wishes to have a permutation representation of the group, this requires more cleverness. The `CosetAction` function can be used to compute the permutation representation of a group on a subgroup. If the subgroup is chosen to have trivial core, then the permutation group obtained will be isomorphic to the original group.
##### `AbelianGroup(G): GrpPC -> GrpAb, Map`
Given an abelian pc-group $G$, return a `GrpAb` group $H$ isomorphic to $G$ and an isomorphism $\phi: G \rightarrow H$.
##### `FPGroup(G): GrpPC -> GrpFP, Map`
A [`GrpFP`](https://docs.magma-maths.org/FinitelyPresentedGroups/FPGroups/index-fpgroups.md#chapgrpfp) representation $F$ of $G$ and the isomorphism from $G$ to $F$.
##### `GPCGroup(G): GrpPC -> GrpGPC, Map`
A [`GrpGPC`](https://docs.magma-maths.org/FinitelyPresentedGroups/PolycyclicGroups/index-polycyclic-groups.md#chapgrpgpc) representation $F$ of $G$ and the isomorphism from $G$ to $F$.
##### `Example: Pc-Group to Permutation Group (ex-b68da2)`
Take one of the groups of order $2^6 * 3^2$.
```magma
> G := SmallGroup(576, 4123);
> G;
GrpPC : G of order 576 = 2^6 * 3^2
PC-Relations:
G.1^2 = Id(G),
G.2^2 = Id(G),
G.3^2 = G.5,
G.4^3 = Id(G),
G.5^2 = G.7,
G.6^2 = G.7,
G.7^2 = Id(G),
G.8^3 = Id(G),
G.2^G.1 = G.2 * G.6,
G.6^G.1 = G.6 * G.7,
G.6^G.2 = G.6 * G.7,
G.8^G.1 = G.8^2
```
Since $G$ is small, we can search for a minimum degree permutation presentation by brute force. First we build a set containing all the subgroups.
```magma
> SL := Subgroups(G);
> T := {X`subgroup: X in SL};
> #T;
243
```
Then, we select those subgroups with trivial core, and find one with the smallest index.
```magma
> TrivCore := {H:H in T| #Core(G,H) eq 1};
> mdeg := Min({Index(G,H):H in TrivCore});
> Good := {H: H in TrivCore| Index(G,H) eq mdeg};
> #Good;
3
> H := Rep(Good);
```
We then use CosetAction to construct the permutation representation on the cosets of $H$.
```magma
> f,P,K := CosetAction(G,H);
> #K;
1
> IsPrimitive(P);
false
```
### More About Presentations
Each pc-group can have up to three pc-presentations associated with it. If the user specifies a consistent presentation in the `PolycyclicGroup`-constructor, then this presentation (the “user” presentation) will be used for all printing and interpretation of element input. If the specified presentation is inconsistent, a runtime error is generated.
Internally, Magma uses a “conditioned” presentation for computation. The composition series associated with this presentation is guaranteed to refine a normal series with elementary abelian factors. If $G$ is a $p$-group, then the composition series is guaranteed to be a central series and the first $d$ pc-generators are a minimal set of generators for the group. Hence, their images generate the Frattini factor group. If the user presentation satisfies these conditions, then it is used as the conditioned presentation. Otherwise, a separate presentation is computed automatically.
Several algorithms rely on a “special” presentation for the group. This presentation exhibits Hall $\pi$-subgroups and a characteristic series with elementary abelian factors. When needed, such a presentation is computed and elements are automatically translated between presentations.
The “compact” presentation is not a presentation used in computation. Rather it provides an efficient means to input and output large pc-groups. This is especially useful for stored collections of groups (libraries or databases).
#### Conditioned Presentations
Magma will compute a pc-presentation which will be used for internal computation, but the user’s presentation will be used for all input and output. The recommended way to access the conditioned internal presentation is via the intrinsic `ConditionedGroup`.
##### Structure Operations
###### `ConditionedGroup(G): GrpPC -> GrpPC`
The internally used, conditioned presentation of the pc-group $G$. The returned group is recorded as a subgroup of $G$ in the relationship tables, so coercion can be used to move between presentations.
###### `IsConditioned(G): GrpPC -> BoolElt`
Returns `true` if $G$ uses the user presentation as the internal presentation, `false` otherwise.
##### Element Operations
###### `LeadingTerm(x): GrpPCElt -> GrpPCElt`
Given an element $x$ of a pc-group $G$ with $n$ pc-generators and a conditioned presentation, where $x$ is of the form $a_1^{\alpha_1}\ldots a_n^{\alpha_n}$, return $a_i^{\alpha_i}$ for the smallest $i$ such that $\alpha_i > 0$. If $x$ is the identity of $G$, then the identity is returned.
###### `LeadingGenerator(x): GrpPCElt -> GrpPCElt`
Given an element $x$ of a pc-group $G$ with $n$ pc-generators and a conditioned presentation, where $x$ is of the form $a_1^{\alpha_1}\ldots a_n^{\alpha_n}$, return $a_i$ for the smallest $i$ such that $\alpha_i > 0$. If $x$ is the identity of $G$, then the identity is returned.
###### `LeadingExponent(x): GrpPCElt -> RngIntElt`
Given an element $x$ of a pc-group $G$ with $n$ pc-generators and a conditioned presentation, where $x$ is of the form $a_1^{\alpha_1}\ldots a_n^{\alpha_n}$, return $\alpha_i$ for the smallest $i$ such that $\alpha_i > 0$. If $x$ is the identity of $G$, then $0$ is returned.
###### `Depth(x): GrpPCElt -> RngIntElt`
Given an element $x$ of a pc-group $G$ with $n$ pc-generators and a conditioned presentation, where $x$ is of the form $a_1^{\alpha_1}\ldots a_n^{\alpha_n}$, return the smallest $i$ such that $\alpha_i > 0$. If $x$ is the identity of $G$, then $0$ is returned.
###### `PCClass(x): GrpPCElt -> RngIntElt`
###### `WeightClass(x): GrpPCElt -> RngIntElt`
The weight class of the element $x$. The `WeightClass` of an arbitrary element of a pc-group $G$ is defined to be $k$ if $x\in G_{\delta_{k-1}}$ and $x\notin G_{\delta_{k}}$. If $x$ is the identity of $G$, then `WeightClass` returns $n + 1$.
#### Special Presentations
A special presentation is one which has several properties described by C.R. Leedham-Green:
**(1)**
The composition series defined by the pc-generators refines the LG-series. The LG-series is a characteristic series which refines the nilpotent series. Within each nilpotent section, it refines the series of successive Frattini factors. Factors of successive terms in the LG-series are elementary abelian $p$-groups, with $p$ increasing through each Frattini factor.
**(2)**
The presentation exhibits a Sylow system. By this we mean that if $\pi$ is a set of primes, then the pc-generators whose corresponding prime lies in $\pi$ will generate a Hall $\pi$-subgroup.
**(3)**
The presentation exhibits “head splittings”. These are certain complements in factors of the group as follows: If $N$ is a term of the nilpotent series of $G$, $M$ the next term (so $N/M$ is a maximal nilpotent factor of $N$), and $F/M$ is the Frattini subgroup of $N/M$, then it is possible to show that $N/F$ has a complement in $G/F$. We say the presentation exhibits this complement (or “splitting”) if the pc-generators of $G$ which are not in $N$ generate a complement for $N$ mod $F$.
Several algorithms rely on having a special presentation for the given group. In these cases, Magma will automatically compute a special presentation. However, if the user wishes to have a special presentation as the user presentation for a group, the function `SpecialPresentation` can be used. This is typically used when implementing new algorithms which rely on the properties of a special presentation. The other functions allow one to identify specific characteristics of a special presentation. They are not defined for arbitrary presentations.
##### `SpecialPresentation(G): GrpPC -> GrpPC`
Returns a new group $H$ which is defined by a special presentation. $H$ is in fact a subgroup of $G$ (equal to $G$) and so one can use the coercion operator (!) to translate elements between the two presentations. Furthermore, any subgroup of $H$ is automatically a subgroup of $G$. For instance, if one computed the center $Z$ of $H$ (using some algorithm relying on the special presentation), $Z$ would be a subgroup of $G$, and would be the center of $G$.
##### `SpecialWeights(G): GrpPC -> [ ]`
A sequence of triples of integers is returned, with one triple corresponding to each pc-generator. The first integer in a triple gives the number of the nilpotent section containing the generator, the second gives the number of the square-free exponent abelian section of that nilpotent section containing it, and the third gives the number of the elementary abelian $p$-group layer that contains the generator. The prime for the generator is not included in the triple (see `PCPrimes`).
##### `NilpotentLength(G): GrpPC -> RngIntElt`
The number of nilpotent factors in the nilpotent series.
##### `NilpotentBoundary(G, i): GrpPC, RngIntElt -> RngIntElt`
The subscript of the last generator in the $i$th nilpotent section, where $i$ lies between $1$ and `NilpotentLength(G)`.
##### `MinorLength(G, i): GrpPC, RngIntElt -> RngIntElt`
The number of minor sections (Frattini factors) in the $i$th nilpotent section of $G$.
##### `MinorBoundary(G, i, j): GrpPC, RngIntElt, RngIntElt -> RngIntElt`
The subscript of the last generator in the $j$th minor section of the $i$th nilpotent section, where $j$ lies between 1 and `MinorLength(G,i)`.
##### `LayerLength(G, i, j): GrpPC, RngIntElt, RngIntElt -> RngIntElt`
The number of elementary abelian $p$-group layers in the $j$th minor section of the $i$th nilpotent section of $G$.
##### `LayerBoundary(G, i, j, k): GrpPC, RngIntElt, RngIntElt, RngIntElt -> RngIntElt`
The subscript of the last generator in the $k$th elementary abelian $p$-group layer of the $j$th minor section of the $i$th nilpotent section, where $k$ lies between 1 and `LayerLength(G,i,j)`.
##### `Example: User and Special Presentations (ex-4806c3)`
We show how user presentations and special presentations can differ. If we define a wreath product using `PolycyclicGroup`, the given presentation becomes the user presentation, but this is not a special presentation for the group.
```magma
> T := PolycyclicGroup b^a=c, c^a=d, d^a=b>;
> T;
GrpPC : T of order 81 = 3^4
PC-Relations:
T.2^T.1 = T.3,
T.3^T.1 = T.4,
T.4^T.1 = T.2
> S := SpecialPresentation(T);
> S;
GrpPC : S of order 81 = 3^4
PC-Relations:
S.2^S.1 = S.2 * S.3^2 * S.4,
S.3^S.1 = S.3 * S.4^2
```
Here we build another wreath product and construct a special presentation.
```magma
> C6 := CyclicGroup(GrpPC,6);
> C2 := CyclicGroup(GrpPC,2);
> G := WreathProduct(C2,C6);
> G;
GrpPC : G of order 384 = 2^7 * 3
PC-Relations:
G.1^2 = G.2,
G.2^3 = Id(G),
G.3^2 = Id(G),
G.4^2 = Id(G),
G.5^2 = Id(G),
G.6^2 = Id(G),
G.7^2 = Id(G),
G.8^2 = Id(G),
G.3^G.1 = G.8,
G.3^G.2 = G.5,
G.4^G.1 = G.6,
G.4^G.2 = G.3,
G.5^G.1 = G.7,
G.5^G.2 = G.4,
G.6^G.1 = G.3,
G.6^G.2 = G.8,
G.7^G.1 = G.4,
G.7^G.2 = G.6,
G.8^G.1 = G.5,
G.8^G.2 = G.7
> H := SpecialPresentation(G);
> H;
GrpPC : H of order 384 = 2^7 * 3
PC-Relations:
H.1^2 = Id(H),
H.2^2 = Id(H),
H.3^3 = Id(H),
H.4^2 = Id(H),
H.5^2 = Id(H),
H.6^2 = Id(H),
H.7^2 = Id(H),
H.8^2 = Id(H),
H.2^H.1 = H.2 * H.4,
H.5^H.3 = H.6,
H.6^H.3 = H.5 * H.6,
H.7^H.1 = H.6 * H.7,
H.7^H.3 = H.8,
H.8^H.1 = H.5 * H.6 * H.8,
H.8^H.3 = H.7 * H.8
```
We can coerce between the presentations.
```magma
> G!(H.2), H!(G.2);
G.6 * G.7 * G.8 H.3
```
Look at some specific features of the presentation.
```magma
> SpecialWeights(H);
[ <1, 1, 1>, <1, 1, 1>, <1, 1, 2>, <1, 2, 1>, <2, 1, 1>, <2, 1, 1>, <2, 1, 1>,
<2, 1, 1> ]
> MinorLength(H,1);
2
> MinorBoundary(H,1,1);
3
```
#### CompactPresentation
When the Magma parser reads in large group presentations of the form
```
S4 := PolycyclicGroup< a, b, c, d | a^2 = 1, b^3 = 1, c^2 = 1,
d^2 = 1, b^a = b^2, c^a = c * d, c^b = c * d, d^b = c >;
```
a large amount of memory and time is used to build all of the expressions involved in the statement. This time is most noticeable when loading in large libraries of Magma code containing many large presentations. The following intrinsics provide a way to avoid this overhead.
##### `CompactPresentation(G): GrpPC -> [RngIntElt]`
Given a pc-group $G$, return a sequence of integers that contains the information needed to define the group’s presentation.
##### `PCGroup(Q : parameters): [RngIntElt] -> GrpPC`
```magma
Check : BoolElt Default: false
ExponentLimit: RngIntElt Default: 20
```
Return a group $G$ in category `GrpPC`, whose presentation is provided by the integer sequence $Q$. Constructing the group from the integer sequence has very low overhead in the parser. The time taken to construct the group is less when the presentation is conditioned. The parameter `Check` indicates whether or not the presentation is checked for consistency. Leaving the `Check` parameter set to `false` speeds the construction of the group, but will be disastrous if the sequence $Q$ does not represent a consistent pc-presentation. Parameter `ExponentLimit` determines the amount of space that will be used by the group to speed calculations. Given `ExponentLimit := e`, the group will store the products $a^i * b^j$ where $a$ and $b$ are generators and $i$ and $j$ are in the range $1$ to $e$.
##### `Example: Compact Presentation for a Library (ex-73c5b4)`
If the user wants to store the definition of a group in a library, the following may be done.
```magma
> S4 := PolycyclicGroup< a, b, c, d | a^2 = 1, b^3 = 1, c^2 = 1, d^2 = 1,
> \indent\indent\indent b^a = b^2, c^a = c * d, c^b = c * d, d^b = c >;
> Q := CompactPresentation( S4 );
> Q;
[ 4, -2, -3, -2, 2, 33, 218, 114, 55 ]
```
The library code would then be
```magma
> Make:=func< | PCGroup(\\[4, 2, 3, 2, 2, 33, 218, 114, 55] : Check := false) >;
```
Note the use of a literal sequence here — see Chapter [Sequences](https://docs.magma-maths.org/SetsSequencesMappings/Sequences/index-sequences.md#chapseq).
### Optimizing Magma Code
#### PowerGroup
If the user is working with enumerated sets of pc-groups that are all subgroups of a common over-group $G$, then the following optimization is strongly recommended. Define the set to have the universe `PowerGroup(G)`. For any subgroup $H$ of $G$, we can find a canonical form for the generators of $H$. This allows us to have a very good hashing function for the subgroups.
##### `Example: Optimising with a Power Group (ex-952208)`
The following example illustrates the optimization.
```magma
> G := ExtraSpecialGroup( GrpPC, 3, 3 );
> P := PowerGroup(G);
> time s1 := { P | sub< G | Random(G), Random(G) > : x in { 1..500} };
Time: 1.140
> time s2 := { Parent(G) | sub< G | Random(G), Random(G) > : x in { 1..500} };
Time: 9.769
```
### $p$-Groups of Tame Genus
The `TameGenus` package contains polynomial-time algorithms to decide isomorphism, construct automorphism groups, and build canonical labels of a class of $p$-groups of nilpotency class $2$ and exponent $p$. We say such groups have *tame genus*, and we provide a function called `IsTameGenusGroup` to check whether the functions in `TameGenus` can be applied to the given group. This class includes $d$-generated groups of order $p^{d + 2}$, exponent $p$, and class $2$.For definitions, theorems, and descriptions of algorithms, see [[BMW17](https://docs.magma-maths.org/references.md#cite-bmw-genus2)]. When appropriate, intrinsics for groups also work for bilinear maps (`TenSpcElt`).
#### Verbose Printing
We have included intrinsics to allow for verbose printing. The string `"TameGenus"` is now accepted by `SetVerbose` with print levels between $0$ and $2$. Level 0 turns off all printing. Level 1 will print out the steps in the algorithms, and level 2 will print timings and extra structural information along the way.
##### `Example: Verbose Printing (ex-e49bb4)`
We demonstrate the verbose printing by constructing a random genus 2 group of order $3^{20 + 2}$.
```magma
> G := RandomGenus2Group(3, [4, 6, 10]);
> #G eq 3^(4 + 6 + 10 + 2);
true
> Genus(G);
2
```
With the verbose printing, we can see steps of the algorithm.
```magma
> SetVerbose("TameGenus", 1);
> A := TGAutomorphismGroup(G);
Extracting the p-central tensor and computing pseudo-isometries.
Checking the radicals.
dim(Rad_V) = 0
dim(Rad_W) = 0
Writing tensor over its centroid.
Tensor has genus 2.
Computing the adjoint algebra.
dim(Adj) = 40
Decomposing tensor into flat and sloped subtensors.
Block dims = [ 4, 6, 10 ]
Number of sloped blocks to lift: 3.
Field is small enough, applying Pfaffian method.
Number of flat blocks to lift: 0.
Constructing the isometry group.
G
| Sp ( 2 , 3 ^ 2 )
*
| Sp ( 2 , 3 ^ 3 )
*
| Sp ( 2 , 3 ^ 5 )
*
| 3 ^ 0 (unipotent radical)
1
Constructing automorphism group from pseudo-isometries.
```
#### Constructors
We introduce functions to construct groups of genus $\leq 2$.
##### `TGRandomGroup(q, n, g : parameters): RngIntElt, RngIntElt, RngIntElt -> GrpPC`
```magma
Exponentp: BoolElt Default: true
```
Given $q=p^m$, $n>0$, and $g>0$, returns a $p$-group $G$ with genus $\leq g$ and order $q^{n+g}$. The algorithm is based on the Universal Coefficients Theorem, see [[LGM02a](https://docs.magma-maths.org/references.md#cite-lgm-book), Chapter 9] for the statement and proof. There is one optional parameter: `Exponentp`.
**(\*)**
`Exponentp`: Set to `false` if the constructor should not force exponent $p$.
##### `Example: Random Groups of Tame Genus (ex-7e07d7)`
We construct a random group using the `TGRandomGroup` constructor. Specifically, we create a group $G$ with exponent $5$ such that the commutator tensor $[,]$ has centroid containing $K={\bf F}_{5^7}$ with genus at most $2$ and where $\rm{dim}_K (G/\Phi(G)) = 8$. First, we create the group.
```magma
> G := TGRandomGroup(5^7, 8, 2);
> #G eq 5^(7*(8 + 2));
true
```
We check that the genus of our group $G$ is at most 2.
```magma
> Genus(G);
2
```
We verify that the commutator tensor has a centroid containing the field of order $5^7$.
```magma
> t := pCentralTensor(G, 1, 1);
> t;
Tensor of valence 3, U2 x U1 >-> U0
U2 : Full Vector space of degree 56 over GF(5)
U1 : Full Vector space of degree 56 over GF(5)
U0 : Full Vector space of degree 28 over GF(5)
> C := Centroid(t);
> Dimension(C);
7
> IsSimple(C);
true
```
##### `RandomGenus2Group(q, d : parameters): RngIntElt, [RngIntElt] -> GrpPC`
```magma
Exponentp: BoolElt Default: true
```
Given $q=p^m$ and $d=[d_1, \dots, d_k]$, where $d_i>0$, return a genus 2 group $G$ whose commutator tensor $[,] : V\times V\rightarrowtail W$ which is ${\bf F}_{q}$-bilinear and whose $\perp$-decomposition has blocks of the prescribed dimensions $d_1,\dots,d_k$ over ${\bf F}_{q}$. Each $d_i=1$ increases the dimension of the radical of $[,]$ by 1 over ${\bf F}_{q}$. There is one optional parameter: `Exponentp`.
**(\*)**
`Exponentp`: Set to `false` if the constructor should not force exponent $p$.
##### `Example: Genus 2 Groups with Prescribed Blocks (ex-3b8b51)`
Unlike the `TGRandomGroup` constructor, if we want to construct a genus 2 group with prescribed block dimensions, we can do this with `RandomGenus2Group`. If we want an elementary abelian direct factor, we can append a sequence of $1$s whose sum is the rank of such a factor. We construct a genus 2 group $G$ with an indecomposable blocks of dimensions $10$, $7$, $4$, $4$, and $1$. Therefore, $G\cong H\times {\mathbb{Z}}/(p)$, where $H$ is directly indecomposable and of order $7^{25+2}$.
```magma
> G := RandomGenus2Group(7, [10, 7, 4, 4, 1]);
> #G eq 7^(10 + 7 + 4 + 4 + 1 + 2);
true
```
We can see these blocks with the genus 2 signature of the group. See `TGSignature` for a description of the output.
```magma
> S := TGSignature(G);
> S;
[* <7, 25, 2>, <1, 0>,
[ 7 ],
[*
[ 1, 0, 1 ],
[ 1, 4, 5 ],
[ 1, 3, 3, 2, 6, 3 ]
*]
*]
```
##### `RandomGenus1Group(q, d, r : parameters): RngIntElt, RngIntElt, RngIntElt -> GrpPC`
```magma
Exponentp: BoolElt Default: true
```
Given $q=p^m$, $d>0$, and $r\geq 0$, return a group $G$ with genus 1 and of order $q^{2d+r+1}$. The center of $G$ has order $q^{r+1}$, and $G$ is $m(2d+r)$-generated. There is one optional parameter: `Exponentp`.
**(\*)**
`Exponentp`: Set to `false` if the constructor should not force exponent $p$.
##### `Example: Heisenberg Groups (ex-3634bf)`
The classic Heisenberg group over a field is an example of a genus 1 group, and one can generalize this construction in a number of ways. We will create a matrix group, over ${\bf F}_{81}$, as a polycyclic group.
```magma
> G := RandomGenus1Group(81, 2, 0);
> #G eq 81^(2*2 + 1);
true
```
We verify that $G$ has genus 1 and that the derived subgroup is isomorphic to $({\mathbb{Z}}/(3))^4$.
```magma
> D := DerivedSubgroup(G);
> IsElementaryAbelian(D);
true
> #D eq 3^4;
true
```
Although the underlying field ${\bf F}_{81}$ is hidden within the relations of the polycyclic presentation, we can still construct it and compute the genus over this larger field.
```magma
> Genus(G);
1
```
##### `Genus2Group(f): RngUPolElt -> GrpPC`
##### `Genus2Group(f): RngMPolElt -> GrpPC`
Given either a univariate or homogeneous multivariate polynomial in two variables over ${\bf F}_{q}$, return a group $G$ whose commutator ${\bf F}_{q}$-tensor has a Pfaffian in the same $\Gamma\rm{L}(2,q)$-orbit as $f$.
##### `Example: Genus 2 Group from a Pfaffian (ex-ff5bc5)`
We construct the genus 2 group $G$ whose (univariate) Pfaffian is equivalent to $f(x) = x^3(x-1)^2(x-2)$ in ${\bf F}_{9}[x]$. Therefore, we expect $|G|=9^{2\cdot 6 + 2}$.
```magma
> P := PolynomialRing(GF(9));
> f := x^3*(x-1)^2*(x-2);
> G := Genus2Group(f);
> #G eq 9^(2*6 + 2);
true
```
The genus 2 signature reveals the block structure. All six $\perp$-indecomposable subspaces are $2$-dimensional.
```magma
> S := TGSignature(G);
> S;
[* <9, 12, 2>, <0, 0>,
[],
[*
[ 1, 1 ],
[ 1, 0, 0 ],
[ 0, 0, 0, 1 ]
*]
*]
```
The output shows that the homogenization of $f$ is equivalent to the polynomial $g(x,y) = x^2y^3(x+y)$ in ${\bf F}_{q}[x,y]$.
#### Direct Indecomposability
Determining the genus of a group $G$ requires knowing the direct indecomposable factors of $G$, so there are functions to decide if $G$ is indecomposable.
##### `IsIndecomposable(G): GrpPC -> BoolElt`
Given a group $G$, decide if $G$ is directly indecomposable. This algorithm is based on algorithms by Wilson in [[Wil12](https://docs.magma-maths.org/references.md#cite-wilson-decomposable)].
##### `IsIndecomposable(t): TenSpcElt -> BoolElt`
Given a tensor $t$, decide if $t$ is directly indecomposable. This algorithm is based on algorithms by Wilson in [[Wil12](https://docs.magma-maths.org/references.md#cite-wilson-decomposable)].
##### `Example: Decomposable Groups (ex-3b99f7)`
We create a decomposable genus 2 group from the `TameGenus` constructors. For example, the group $G$ with a Pfaffian equivalent to $xy$ is decomposable.
```magma
> P := PolynomialRing(GF(7), 2);
> f := x*y;
> G := Genus2Group(f);
> G;
GrpPC : G of order 117649 = 7^6
PC-Relations:
G.3^G.1 = G.3 * G.5,
G.4^G.2 = G.4 * G.6
> IsIndecomposable(G);
false
```
This example also shows that `TGRandomGroup` may return a group that is directly decomposable.
##### `Example: Indecomposable Central Products (ex-f8f20b)`
We create a directly indecomposable group $G$ that is a central product of two genus 2 groups.
```magma
> G := RandomGenus2Group(5, [3, 4]);
> #G eq 5^(3 + 4 + 2);
true
> IsIndecomposable(G);
true
```
We observe the central factors from the genus 2 signature of $G$. We see that $G$ is a central product of genus 2 groups of order $5^5$ and $5^6$.
```magma
> TGSignature(G);
[* <5, 7, 2>, <0, 0>,
[ 3 ],
[*
[ 1, 0, 2 ]
*]
*]
```
#### Genus
##### `Genus(G): GrpPC -> RngIntElt`
Given a directly indecomposable $p$-group $G$, return the genus of $G$ as defined in [[BMW17](https://docs.magma-maths.org/references.md#cite-bmw-genus2)].
##### `Genus(t): TenSpcElt -> RngIntElt`
Given a directly indecomposable tensor $t: V\times V\rightarrowtail W$, return the rank of $W$ as a $C$-module. Only implemented for algebras $C$ such that $C/J(C)$ is simple, where $J(C)$ is the Jacobson radical.
##### `Example: Genus of Small Groups (ex-40dc90)`
We determine the genus of some groups in the Small Group library. Let $G$ be the group of order $3^6$ with ID number 440. Its derived subgroup is isomorphic to $({\mathbb{Z}}/(3))^2$, and $G$ is genus 2.
```magma
> G := SmallGroup(3^6, 440);
> #DerivedSubgroup(G) eq 3^2;
true
> IsElementaryAbelian(DerivedSubgroup(G));
true
> Genus(G);
2
```
Let $H$ be the group of order $3^6$ with ID number 469. Its derived subgroup is isomorphic to $({\mathbb{Z}}/(3))^2$ also, but $H$ is genus 1.
```magma
> H := SmallGroup(3^6, 469);
> #DerivedSubgroup(H) eq 3^2;
true
> IsElementaryAbelian(DerivedSubgroup(H));
true
> Genus(H);
1
```
We can see this difference in genus in multiple ways. If we extract the commutator tensor from both groups, one is bilinear over a quadratic field extension where the other tensor is not. The algebra that records this is the centroid of a tensor, see `Centroid`.
```magma
> s := pCentralTensor(G, 1, 1);
> t := pCentralTensor(H, 1, 1);
> C_G := Centroid(s);
> C_H := Centroid(t);
> C_G;
Matrix Algebra of degree 6 with 2 generators over GF(3)
> C_H;
Matrix Algebra of degree 6 with 2 generators over GF(3)
```
The centroid associated to the tensor $s$ is $2$-dimensional but with a nontrivial Jacobson radical. The centroid associated to the tensor $t$ is $2$-dimensional and a simple ${\bf F}_{3}$-algebra.
```magma
> Dimension(C_G);
2
> Dimension(C_H);
2
> WedderburnDecomposition(C_G);
Matrix Algebra of degree 6 with 1 generator over GF(3)
Matrix Algebra of degree 6 with 1 generator over GF(3)
> IsSimple(C_H);
true
```
##### `IsTameGenusGroup(G): Group -> BoolElt`
Decides if the functions in the `TameGenus` package (prefixed with `TG`) can be applied to the given group $G$.
##### `IsTameGenusTensor(t): TenSpcElt -> BoolElt`
Decides if the functions in the `TameGenus` package (prefixed with `TG`) can be applied to the given tensor $t$.
##### `Example: Group Not of Tame Genus (ex-da6133)`
We create a group that is not covered by the `TameGenus` package. The small groups of order $3^6$ with IDs 440 and 469 both have tame genus: 2 and 1 respectively. The direct product of the two groups has genus 2, but because the group is not directly indecomposable, the current implementation of `TameGenus` cannot handle it.
```magma
> H1 := SmallGroup(3^6, 440);
> H2 := SmallGroup(3^6, 469);
> G := DirectProduct(H1, H2);
> G;
GrpPC : G of order 531441 = 3^12
PC-Relations:
G.2^G.1 = G.2 * G.5,
G.3^G.1 = G.3 * G.6,
G.3^G.2 = G.3 * G.5,
G.4^G.1 = G.4 * G.5,
G.8^G.7 = G.8 * G.11,
G.9^G.7 = G.9 * G.12,
G.9^G.8 = G.9 * G.11^2 * G.12,
G.10^G.7 = G.10 * G.11 * G.12,
G.10^G.8 = G.10 * G.11
> IsTameGenusGroup(G);
false
```
##### `Example: Filtering Small Groups by Tame Genus (ex-063b44)`
We use the `IsTameGenusGroup` to filter large databases down to the ones covered by `TameGenus`. We do that with the Small Group library for groups of order $3^6$, and we find there are seven such groups. Recall, that these groups must have prime exponent.
```magma
> G2_SG := [*G : G in SmallGroups(3^6) | IsTameGenusGroup(G)*];
> #G2_SG;
7
```
We further filter these groups based on their genus, and we find that there are six groups of positive genus and one abelian group.
```magma
> G1 := [*G : G in G2_SG | Genus(G) eq 1*];
> G2 := [*G : G in G2_SG | Genus(G) eq 2*];
> #G1;
3
> #G2;
3
```
We determine the tame genus signatures to show that all these groups yield different signatures. We first consider the genus 1 groups.
```magma
> for G in G1 do
> TGSignature(G);
> end for;
[* <9, 2, 1>, <0, 0>, [* *], [* *] *]
[* <3, 2, 1>, <3, 0>, [* *], [* *] *]
[* <3, 4, 1>, <1, 0>, [* *], [* *] *]
```
The genus 2 groups have the following signatures.
```magma
> for G in G2 do
> TGSignature(G);
> end for;
[* <3, 3, 2>, <1, 0>,
[ 3 ],
[* *]
*]
[* <3, 4, 2>, <0, 0>,
[],
[*
[ 0, 0, 1 ]
*]
*]
[* <3, 4, 2>, <0, 0>,
[],
[*
[ 1, 0 ],
[ 0, 1 ]
*]
*]
```
#### Isomorphism
##### `TGIsIsomorphic(G, H : parameters): GrpPC, GrpPC -> BoolElt`
```magma
Cent : BoolElt Default: true
Constructive: BoolElt Default: true
Method : RngIntElt Default: 0
```
Given class $\leq 2$, exponent $p$, directly indecomposable odd-ordered $p$-groups $G$ and $H$ of genus $\leq 2$, decide if $G\cong H$. This will accept groups $G$ of the form $G\cong A\times K$, where $A$ is abelian and $K$ is directly indecomposable. There are three optional parameters: `Cent`, `Constructive`, and `Method`.
**(\*)**
`Cent`: If $G$ and $H$ are known to have genus $\leq 2$ over the prime field, then set to `false` to save some time.
**(\*)**
`Constructive`: Set to `false` if an explicit isomorphism is not needed.
**(\*)**
`Method`: Input from $\{ 0,1,2\}$ is acceptable. This determines the method for handling the sloped part of the tensor. If the adjoint-tensor method should be used, set to $1$. If the Pfaffian method should be used, set to $2$. The default will try to find the optimal method based on the input; see [[BMW17](https://docs.magma-maths.org/references.md#cite-bmw-genus2)] for details.
##### `Example: Isomorphism Testing (ex-13bda5)`
We create an isomorphic pair of groups in two different ways, and then we construct an isomorphism between the two. This example can be seen as verifying Theorem 1.1 of [[LM18](https://docs.magma-maths.org/references.md#cite-lm-semi-extraspecial)]. We construct groups $G$ and $H$ from two random irreducible cubic polynomials in ${\bf F}_{67}[x]$.
```magma
> f := RandomIrreduciblePolynomial(GF(67), 3);
> g := RandomIrreduciblePolynomial(GF(67), 3);
> f, g;
$.1^3 + 36*$.1^2 + 26*$.1 + 33
$.1^3 + 57*$.1^2 + 24*$.1 + 65
> G := Genus2Group(f);
> H := Genus2Group(g);
```
In this case, the default method will run the adjoint-tensor method. We can see this if we turn on verbose printing.
```magma
> SetVerbose("TameGenus", 1);
> isomorphic, phi := TGIsIsomorphic(G, H);
Extracting p-central tensors and deciding pseudo-isometry.
Checking the radicals.
dim(Rad_V) = 0
dim(Rad_W) = 0
Checking the radicals.
dim(Rad_V) = 0
dim(Rad_W) = 0
Writing tensor over its centroid.
Writing tensor over its centroid.
Computing the adjoint algebra.
dim(Adj_s) = 12
dim(Adj_t) = 12
Computing the adjoint algebra.
Genus 2 case.
Decomposing tensors into flat and sloped subtensors.
Block dims = [ 6 ]
PGammaL is larger than symmetric group, applying adjoint-tensor method.
```
We see that the two groups are isomorphic, and $\phi$ is such an isomorphism.
```magma
> isomorphic;
true
> phi;
Homomorphism of GrpPC : G into GrpPC : H induced by
G.1 |--> H.1 * H.2^41 * H.3^30 * H.4^58 * H.5^43 * H.6^30
G.2 |--> H.1^53 * H.2^4 * H.3^34 * H.4^54 * H.5^6 * H.6^25
G.3 |--> H.1^5 * H.2^7 * H.3^49 * H.4^52 * H.5^21 * H.6^7
G.4 |--> H.1^30 * H.2^4 * H.3^17 * H.4^53 * H.5^40 * H.6^9
G.5 |--> H.1^14 * H.2^21 * H.3^30 * H.4^24 * H.5^38 * H.6^34
G.6 |--> H.1^47 * H.2^46 * H.3^66 * H.4^65 * H.5^30 * H.6^30
G.7 |--> H.7^10 * H.8^18
G.8 |--> H.7^54 * H.8^12
```
To run the Pfaffian test, set the `Method` to 2. This method is noticeably slower for these groups and should not be used for very large primes.
```magma
> isomorphic, phi2 := TGIsIsomorphic(G, H : Method := 2);
Extracting p-central tensors and deciding pseudo-isometry.
Checking the radicals.
dim(Rad_V) = 0
dim(Rad_W) = 0
Checking the radicals.
dim(Rad_V) = 0
dim(Rad_W) = 0
Writing tensor over its centroid.
Writing tensor over its centroid.
Computing the adjoint algebra.
dim(Adj_s) = 12
dim(Adj_t) = 12
Computing the adjoint algebra.
Genus 2 case.
Decomposing tensors into flat and sloped subtensors.
Block dims = [ 6 ]
Method set to Pfaffian.
> phi2;
Homomorphism of GrpPC : G into GrpPC : H induced by
G.1 |--> H.1^47 * H.2^54 * H.3^54
G.2 |--> H.1^63 * H.2^33 * H.3^15
G.3 |--> H.1^26 * H.2^3 * H.3^60
G.4 |--> H.4^44 * H.5^61 * H.6^16
G.5 |--> H.4^66 * H.5^26 * H.6^36
G.6 |--> H.4^57 * H.5^6 * H.6^30
G.7 |--> H.7^62 * H.8^42
G.8 |--> H.7^18 * H.8^58
```
##### `TGIsPseudoIsometric(s, t : parameters): TenSpcElt, TenSpcElt -> BoolElt, Hmtp`
```magma
Cent : BoolElt Default: true
Constructive: BoolElt Default: true
Method : RngIntElt Default: 0
```
Given directly indecomposable, alternating tensors $s, t : V\times V \rightarrowtail W$, where $V$ and $W$ are ${\bf F}_{q}$-vector spaces of odd order, decide if $s$ is pseudo-isometric to $t$. This will accept tensors with nontrivial radicals and coradicals. There are three optional parameters: `Cent`, `Constructive`, and `Method`.
**(\*)**
`Cent`: If $G$ and $H$ are known to have genus $\leq 2$ over the prime field, then set to `false` to save some time.
**(\*)**
`Constructive`: Set to `false` if an explicit isomorphism is not needed.
**(\*)**
`Method`: Input from $\{ 0,1,2\}$ is acceptable. This determines the method for handling the sloped part of the tensor. If the adjoint-tensor method should be used, set to $1$. If the Pfaffian method should be used, set to $2$. The default will try to find the optimal method based on the input; see [[BMW17](https://docs.magma-maths.org/references.md#cite-bmw-genus2)] for details.
##### `Example: Pseudo-Isometric Tensors (ex-e03ee8)`
A pair of alternating matrices determines a tensor of tame genus. We construct a pair of pseudo-isometric tensors by applying a change of bases map. This is essentially how Experiment A from [[BMW17](https://docs.magma-maths.org/references.md#cite-bmw-genus2)] was conducted. Generating random $50\times 50$ matrices over ${\bf F}_{3}$, we construct two tensors $s,t : {\bf F}_{3}^{50} \times {\bf F}_{3}^{50}\rightarrowtail{\bf F}_{3}^2$.
```magma
> M := RandomMatrix(GF(3), 50, 50);
> N := RandomMatrix(GF(3), 50, 50);
> Forms1 := [M - Transpose(M), N - Transpose(N)];
> s := Tensor(Forms1, 2, 1);
> s;
Tensor of valence 3, U2 x U1 >-> U0
U2 : Full Vector space of degree 50 over GF(3)
U1 : Full Vector space of degree 50 over GF(3)
U0 : Full Vector space of degree 2 over GF(3)
> IsAlternating(s);
true
```
We construct a random invertible co-homotopism $\varphi = (\varphi_1, \varphi_0)$ such that $\varphi_1\in {\operatorname{GL}}(50, 3)$ and $\varphi_0\in{\operatorname{GL}}(2, 3)$. We define a new and pseudo-isometric tensor $t=s^{\varphi}$ in this way.
```magma
> X := Random(GL(50, 3));
> Y := Random(GL(2, 3));
> Maps := [*X, X, Y*];
> H := Homotopism(Maps, CohomotopismCategory(3));
> t := s @ H;
> t;
Tensor of valence 3, U2 x U1 >-> U0
U2 : Full Vector space of degree 50 over GF(3)
U1 : Full Vector space of degree 50 over GF(3)
U0 : Full Vector space of degree 2 over GF(3)
> s eq t;
false
```
We verify that both $s$ and $t$ are pseudo-isometric, and since we do not need to write these tensors over their centroid, we avoid that step by setting `Cent` to `false`.
```magma
> pisometric, Phi := TGIsPseudoIsometric(s, t : Cent :=false);
> pisometric;
true
> Phi.0;
[0 1]
[2 2]
```
#### Automorphism Groups
##### `TGAutomorphismGroup(G : parameters): GrpPC -> GrpAuto`
```magma
Cent : BoolElt Default: true
Method: RngIntElt Default: 0
Mat : BoolElt Default: false
```
Given a directly indecomposable odd-ordered $p$-group $G$, of class $\leq 2$, exponent $p$, and genus $\leq 2$, return ${\operatorname{Aut}}(G)$. This will accept groups $G$ of the form $G\cong A\times K$, where $A$ is abelian and $K$ is directly indecomposable. This intrinsic provides three optional parameters: `Cent`, `Method`, and `Mat`.
**(\*)**
`Cent`: If $G$ and $H$ are known to have genus $\leq 2$ over the prime field, then set to `false` to save some time.
**(\*)**
`Method`: Input from $\{ 0,1,2\}$ is acceptable. This determines the method for handling the sloped part of the tensor. If the adjoint-tensor method should be used, set to $1$. If the Pfaffian method should be used, set to $2$. The default will try to find the optimal method based on the input; see [[BMW17](https://docs.magma-maths.org/references.md#cite-bmw-genus2)] for details.
**(\*)**
`Mat`: Set to `true` for a linear representation of the automorphism group. The row vectors of the matrix correspond to the given polycyclic vectors from the polycyclic presentation.
##### `Example: Automorphisms of a Flat Indecomposable Group (ex-36d32b)`
We build a flat indecomposable genus 2, $p$-group $G$ and construct its automorphism group. We know that ${\operatorname{Aut}}(G)$ maps surjectivity onto ${\operatorname{GL}}(2, p)$, so we verify that $|{\operatorname{Aut}}(G)|$ is divisible by $|{\operatorname{GL}}(2, p)| = (p^2-1)(p^2-p)$. This corresponds to the quotient of the pseudo-isometry group by the isometry group.
```magma
> p := 541;
> G := RandomGenus2Group(p, [29]);
> #G eq p^(29 + 2);
true
> A := TGAutomorphismGroup(G);
> IsDivisibleBy(#A, #GL(2, p));
true
```
The isometry group of the corresponding commutator tensor has an elementary abelian unipotent radical of rank $28$, and so is isomorphic to an extension of ${\operatorname{GL}}(1, p)$ by $({\mathbb{Z}}/(p))^{28}$, as seen in [[BW12b](https://docs.magma-maths.org/references.md#cite-bw-isometry)]. Therefore, we verify that we have constructed all automorphisms as
$$
|{\operatorname{Aut}}(G)| = (p - 1)p^{28} \cdot (p^2-1)(p^2-p) \cdot p^{29\cdot 2}.
$$
```magma
> #A eq (p - 1)*p^28 * (p^2 - 1)*(p^2 - p) * p^(29*2);
true
```
##### `TGPseudoIsometryGroup(t : parameters): TenSpcElt -> GrpMat`
```magma
Cent : BoolElt Default: true
Method: RngIntElt Default: 0
```
Given a directly indecomposable, alternating tensor $t : V \times V \rightarrowtail W$, where $V$ and $W$ are ${\bf F}_{q}$-vector spaces for odd $q$, return the pseudo-isometry group of $t$ as a subgroup of ${\operatorname{GL}}(V)\times {\operatorname{GL}}(W)$. This accepts tensors with nontrivial radicals and coradicals. This intrinsic provides two optional parameters: `Cent` and `Method`.
**(\*)**
`Cent`: If $G$ and $H$ are known to have genus $\leq 2$ over the prime field, then set to `false` to save some time.
**(\*)**
`Method`: Input from $\{ 0,1,2\}$ is acceptable. This determines the method for handling the sloped part of the tensor. If the adjoint-tensor method should be used, set to $1$. If the Pfaffian method should be used, set to $2$. The default will try to find the optimal method based on the input; see [[BMW17](https://docs.magma-maths.org/references.md#cite-bmw-genus2)] for details.
##### `Example: Tensors over an Extension Field (ex-35a1af)`
For $K$-vector spaces $V$ and $W$, we create a genus 2 alternating tensor $t: V \times V\rightarrowtail W$ such that $t$ is bilinear over an extension field $E/K$ and $\rm{dim}_E(W)=2$. One way to do this is with the constructors `RandomGenus2Group` and `pCentralTensor`.
```magma
> G := RandomGenus2Group(3^2, [6]);
> t := pCentralTensor(G, 1, 1);
> t;
Tensor of valence 3, U2 x U1 >-> U0
U2 : Full Vector space of degree 12 over GF(3)
U1 : Full Vector space of degree 12 over GF(3)
U0 : Full Vector space of degree 4 over GF(3)
> Genus(t);
2
```
The Pfaffian of $t$ is an irreducible cubic over ${\bf F}_{9}$, so computing its pseudo-isometry group may contain elements of $\rm{Gal}({\bf F}_{9})$.
```magma
> PI := TGPseudoIsometryGroup(t);
> Random(PI);
[0 1 0 0 0 2 1 1 0 2 1 0 0 0 0 0]
[2 0 0 0 1 0 0 2 1 0 1 2 0 0 0 0]
[1 1 0 0 0 1 1 1 0 0 2 1 0 0 0 0]
[0 2 0 0 2 0 0 2 0 0 1 1 0 0 0 0]
[1 2 2 0 0 2 2 2 1 0 0 0 0 0 0 0]
[2 2 2 1 1 0 0 1 1 2 0 0 0 0 0 0]
[2 2 2 0 1 0 1 0 2 2 1 2 0 0 0 0]
[0 1 2 1 1 2 1 2 0 1 2 2 0 0 0 0]
[2 0 1 0 2 2 2 1 1 1 0 0 0 0 0 0]
[2 1 1 2 0 1 1 1 0 2 0 0 0 0 0 0]
[0 2 0 1 2 2 1 1 0 1 1 0 0 0 0 0]
[1 0 2 0 0 1 0 2 2 0 1 2 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0]
[0 0 0 0 0 0 0 0 0 0 0 0 2 0 1 2]
[0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0]
> Factorization(#PI);
[ <2, 8>, <3, 7>, <5, 1>, <7, 1>, <13, 1>, <73, 1> ]
```
Indeed, the pseudo-isometry group may not be linear over the centroid but semi-linear. To see the discrepancy, we rewrite $t$ over its centroid and determine its pseudo-isometry group as a subgroup of ${\operatorname{GL}}_E(V)\times {\operatorname{GL}}_E(W)$. Note that this group is smaller by a factor of $2$. We see that the pseudo-isometry group of $t$ is strictly semi-linear over ${\bf F}_{9}$, as there exists a Galois involution.
```magma
> s := TensorOverCentroid(t);
> s;
Tensor of valence 3, U2 x U1 >-> U0
U2 : Full Vector space of degree 6 over GF(3^2)
U1 : Full Vector space of degree 6 over GF(3^2)
U0 : Full Vector space of degree 2 over GF(3^2)
> PI_C := TGPseudoIsometryGroup(s);
> Random(PI_C);
[ 1 $.1^7 1 $.1^2 $.1^2 $.1^5 0 0]
[ $.1 2 $.1^7 $.1^3 $.1^6 $.1^5 0 0]
[$.1^7 $.1^2 $.1^7 1 $.1^6 $.1^2 0 0]
[$.1^7 $.1^7 $.1^7 $.1^3 $.1^7 1 0 0]
[ 2 $.1^6 $.1^3 $.1^2 $.1^3 0 0 0]
[$.1^7 $.1 $.1^7 $.1^6 $.1^6 $.1^7 0 0]
[ 0 0 0 0 0 0 2 $.1^7]
[ 0 0 0 0 0 0 $.1^3 $.1^5]
> Factorization(#PI_C);
[ <2, 7>, <3, 7>, <5, 1>, <7, 1>, <13, 1>, <73, 1> ]
```
#### Canonical Labelling
##### `TGSignature(G): GrpPC -> List`
Given an odd-ordered $p$-group $G\cong A \times H$ of genus $\leq 2$, class $\leq 2$, and exponent $p$, return the canonical tame genus signature as a list with four entries. For groups with genus $\leq 1$, the last two entries will be empty. We describe the entries.
**(1)**
The first is a triple of three integers $(q, d, e)$ such that associated fully nondegenerate commutator tensor of $H$ has the form ${\bf F}_{q}^d\times {\bf F}_{q}^d\rightarrowtail {\bf F}_{q}^e$. Here, ${\bf F}_{q}$ is the largest field $F$ which the commutator tensor is $F$-bilinear.
**(2)**
The second entry is a pair of integers $(r, c)$, where $A \cong ({\mathbb{Z}}/(p))^r$ and $c=0$.
**(3)**
The third entry is a sequence of odd integers corresponding to the dimensions of the flat indecomposable spaces.
**(4)**
The fourth and last entry is a list sequences in ${\bf F}_{q}$ of possibly different lengths. A sequence $[c_1,\dots, c_{d+1}]$ in the second entry corresponds to the coefficients of the homogeneous polynomial in $x$ and $y$ in degree $d$:
$$
c_1x^d + c_2 x^{d-1}y + c_3 x^{d-2}y^2 + \cdots + c_{d+1}y^d.
$$
Because this is a canonical label, two groups are isomorphic if, and only if, their tame genus signatures are equal. See [[BMW17](https://docs.magma-maths.org/references.md#cite-bmw-genus2)] for details on how the last two entries describe a genus 2 group.
##### `TGSignature(t): TenSpcElt -> List`
Given an alternating, directly indecomposable tensor $t:V\times V\rightarrowtail W$ of genus $\leq 2$, where $V$ and $W$ are ${\bf F}_{q}$-vector spaces for odd $q$, return the canonical tame genus signature as a list with four entries. For tensors with genus $\leq 1$, the last two entries will be empty. We describe the entries.
**(1)**
The first is a triple of three integers $(q^f, d, e)$ such that associated fully nondegenerate tensor of $t$ has the form ${\bf F}_{q^f}^d\times {\bf F}_{q^f}^d\rightarrowtail {\bf F}_{q^f}^e$. Here, ${\bf F}_{q^f}$ is the largest field $F$ which the associated fully nondegenerate tensor is $F$-bilinear.
**(2)**
The second entry is a pair of integers $(r, c)$, where the radical of $t$ is $r$-dimensional and the codimension of the image of $t$ in $W$ is $c$, both are determined over ${\bf F}_{q}$.
**(3)**
The third entry is a sequence of odd integers corresponding to the dimensions of the flat indecomposable spaces.
**(4)**
The fourth and last entry is a list sequences in ${\bf F}_{q}$ of possibly different lengths. A sequence $[c_1,\dots, c_{d+1}]$ in the second entry corresponds to the coefficients of the homogeneous polynomial in $x$ and $y$ in degree $d$:
$$
c_1x^d + c_2 x^{d-1}y + c_3 x^{d-2}y^2 + \cdots + c_{d+1}y^d.
$$
Because this is a canonical label, two tensors are pseudo-isometric if, and only if, their tame genus signatures are equal. See [[BMW17](https://docs.magma-maths.org/references.md#cite-bmw-genus2)] for details on how the last two entries describe a genus 2 tensor.
##### `Example: Canonical Labels with Many Blocks (ex-bbc04e)`
We construct a genus 2 group $G\cong A \times H$, where $A$ is abelian and $H$ is directly indecomposable but is the central product of many smaller genus 2 groups.
```magma
> blocks := [1, 1, 1, 2, 2, 3, 3, 5, 6];
> G := RandomGenus2Group(9, blocks);
> #G eq 9^(&+blocks + 2);
true
```
Because $G$ was created with the field ${\bf F}_{9}$ and since there are three $1$-dimensional blocks, we expect $|A| = 9^3 = 3^6$.
```magma
> TGSignature(G);
[* <9, 21, 2>, <6, 0>,
[ 3, 3, 5 ],
[*
[ 0, 1 ],
[ 1, 1 ],
[ 1, 2, 2, 2 ]
*]
*]
```
The first entry of this list tells us that the group $H$ has order $9^{21 + 2}$ and that the commutator tensor of $H$ is ${\bf F}_{9}$-bilinear. The second entry reports that $A\cong ({\mathbb{Z}}/(3))^6$. The third and fourth entries show that $H$ is a central product of six indecomposable groups: three flats of orders $9^{3+2}$, $9^{3+2}$, and $9^{5+2}$, and three sloped with Pfaffians in ${\bf F}_{9}[x,y]$ equivalent to
$$
y, x + y, x^3 + 2x^2y + 2xy^2 + 2y^3.
$$
##### `Example: Tame Genus Signatures of Small Groups (ex-15bce1)`
We run through all the small groups of order $3^7$ and determine their tame genus signatures. There are $9310$ such groups, and $10$ of them are covered by `TameGenus`.
```magma
> TG_SG := SmallGroupProcess(3^7, IsTameGenusGroup);
>
> repeat
> G := Current(TG_SG);
> _, ID := CurrentLabel(TG_SG);
> print "Small group ID:", ID;
> TGSignature(G);
> Advance(~TG_SG);
> until IsEmpty(TG_SG);
```
The loop yields the following output.
```magma
Small group ID: 9106
[* <3, 3, 2>, <2, 0>,
[ 3 ],
[* *]
*]
Small group ID: 9107
[* <3, 4, 2>, <1, 0>,
[],
[*
[ 1, 0 ],
[ 0, 1 ]
*]
*]
Small group ID: 9108
[* <3, 4, 2>, <1, 0>,
[],
[*
[ 0, 0, 1 ]
*]
*]
Small group ID: 9109
[* <9, 2, 1>, <1, 0>, [* *], [* *] *]
Small group ID: 9110
[* <3, 5, 2>, <0, 0>,
[ 3 ],
[*
[ 0, 1 ]
*]
*]
Small group ID: 9111
[* <3, 5, 2>, <0, 0>,
[ 5 ],
[* *]
*]
Small group ID: 9302
[* <3, 2, 1>, <4, 0>, [* *], [* *] *]
Small group ID: 9305
[* <3, 4, 1>, <2, 0>, [* *], [* *] *]
Small group ID: 9308
[* <3, 6, 1>, <0, 0>, [* *], [* *] *]
Small group ID: 9310
[* <3, 7, 0>, <7, 0>, [* *], [* *] *]
```
## Black-Box Groups
- [Introduction](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/introduction.md)
- [Construction of an SLP-Group and its Elements](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/creation.md)
- [Structure Constructors](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/creation.md#structure-constructors)
- [`NaturalBlackBoxGroup(H): Grp → GrpBB`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/creation.md#function-naturalblackboxgroup-grp)
- [Construction of an Element](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/creation.md#construction-of-an-element)
- [`Identity(G): GrpBB → GrpBBElt`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/creation.md#function-identity-grpbb)
- [`Id(G): GrpBB → GrpBBElt`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/creation.md#function-id-grpbb)
- [`G ! 1: GrpBB, RngIntElt → GrpBBElt`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/creation.md#operation-op-grpbb-rngintelt)
- [Arithmetic with Elements](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation.md)
- [`u * v: GrpBBElt, GrpBBElt → GrpBBElt`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation.md#operation-op-times-grpbbelt-grpbbelt)
- [`u ^ m: GrpBBElt, RngIntElt → GrpBBElt`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation.md#operation-op-pow-grpbbelt-rngintelt)
- [`u ^ v: GrpBBElt, GrpBBElt → GrpBBElt`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation.md#operation-op-pow-grpbbelt-grpbbelt)
- [`(u, v): GrpBBElt, GrpBBElt → GrpBBElt`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation.md#literal-literal-u-v-grpbbelt-grpbbelt-grpbbelt)
- [Accessing the Defining Generators](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation.md#accessing-the-defining-generators)
- [`G . i: GrpBB, RngIntElt → GrpBBElt`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation.md#operation-operation-grpbb-rngintelt-grpbbelt)
- [`Generators(G): GrpBB → { GrpBBElt}`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation.md#function-generators-grpbb)
- [`NumberOfGenerators(G): GrpBB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation.md#function-numberofgenerators-grpbb)
- [`Ngens(G): GrpBB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation.md#function-ngens-grpbb)
- [Operations on Elements](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation-element.md)
- [Equality and Comparison](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation-element.md#equality-and-comparison)
- [`u eq v: GrpBBElt, GrpBBElt → BoolElt`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation-element.md#operation-op-eq-grpbbelt-grpbbelt)
- [`u ne v: GrpBBElt, GrpBBElt → BoolElt`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation-element.md#operation-op-ne-grpbbelt-grpbbelt)
- [Attributes of Elements](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation-element.md#attributes-of-elements)
- [`Parent(u): GrpBBElt → GrpBB`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation-element.md#function-parent-grpbbelt)
- [`UnderlyingElement(u): GrpBBElt → GrpElt`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation-element.md#function-underlyingelement-grpbbelt)
- [`Order(u): GrpBBElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation-element.md#function-order-grpbbelt)
- [Example: Standard Generators of M24](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/operation-element.md#example-ex-124120)
- [Set-Theoretic Operations](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/set.md)
- [Membership and Equality](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/set.md#membership-and-equality)
- [`g in G: GrpBBElt, GrpBB → BoolElt`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/set.md#operation-op-in-grpbbelt-grpbb)
- [Set Operations](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/set.md#set-operations)
- [`PseudoRandom(G): GrpBB → GrpBBElt`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/set.md#function-pseudorandom-grpbb)
- [`Rep(G): GrpBB → GrpBBElt`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/set.md#function-rep-grpbb)
- [Coercions Between Related Groups](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/set.md#coercions-between-related-groups)
- [`G ! g: GrpBB, GrpBBElt → GrpBBElt`](https://docs.magma-maths.org/FiniteGroups/BlackBoxGroups/set.md#operation-op-grpbb-grpbbelt)
### Introduction
This Chapter describes the category of black-box groups (BB-groups). The name in Magma for the category of BB-groups is `GrpBB`.
### Construction of an SLP-Group and its Elements
#### Structure Constructors
Magma’s black-box groups are built on Magma’s other group types. The basic constructor takes a group and returns a corresponding black-box group. The element set of the black-box group is essentially the same as the element set of the original group, and the group operations are inherited from the original group.
##### `NaturalBlackBoxGroup(H): Grp -> GrpBB`
Construct the natural black-box group from the concrete group $H$.
#### Construction of an Element
##### `Identity(G): GrpBB -> GrpBBElt`
##### `Id(G): GrpBB -> GrpBBElt`
##### `G ! 1: GrpBB, RngIntElt -> GrpBBElt`
Construct the identity element for the BB-group $G$.
### Arithmetic with Elements
#### `u * v: GrpBBElt, GrpBBElt -> GrpBBElt`
Construct the product of elements $u$ and $v$ of the BB-group $G$.
#### `u ^ m: GrpBBElt, RngIntElt -> GrpBBElt`
Given an integer $m$ and $u$, an element of BB-group $G$, return the element of $G$ corresponding to the $m$-th power of $u$.
#### `u ^ v: GrpBBElt, GrpBBElt -> GrpBBElt`
Given $u$ and $v$, elements of BB-group $G$, return the element of $G$ corresponding to the conjugate of $u$ by $v$, i.e. $v^{-1}*u*v$.
#### `(u, v): GrpBBElt, GrpBBElt -> GrpBBElt`
Commutator of the elements $u$ and $v$, i.e. the element $u^{-1}*v^{-1}*u*v$. Here $u$ and $v$ must belong to the same BB-group $G$.
#### Accessing the Defining Generators
The functions described here provide access to basic information stored for a BB-group $G$.
##### `G . i: GrpBB, RngIntElt -> GrpBBElt`
The $i$-th generator for $G$.
##### `Generators(G): GrpBB -> { GrpBBElt}`
A set containing the generators for $G$.
##### `NumberOfGenerators(G): GrpBB -> RngIntElt`
##### `Ngens(G): GrpBB -> RngIntElt`
The number of generators for $B$.
### Operations on Elements
#### Equality and Comparison
##### `u eq v: GrpBBElt, GrpBBElt -> BoolElt`
Returns `true` if and only if the underlying concrete group elements for $u$ and $v$ are equal.
##### `u ne v: GrpBBElt, GrpBBElt -> BoolElt`
Returns `true` if and only if the underlying concrete group elements for $u$ and $v$ are not equal.
#### Attributes of Elements
##### `Parent(u): GrpBBElt -> GrpBB`
The parent group $G$ of the element $u$.
##### `UnderlyingElement(u): GrpBBElt -> GrpElt`
The concrete group element corresponding to the BB-group element $u$.
##### `Order(u): GrpBBElt -> RngIntElt`
The order of the underlying concrete group element of $u$.
##### `Example: Standard Generators of M24 (ex-124120)`
The following function takes a black box group isomorphic to $M_{24}$ and finds standard generators. It is taken from the ATLAS of Finite Group Representations page on $M_{24}$.
```magma
> m24_standard := function(B)
> repeat a := PseudoRandom(B); until Order(a) eq 10;
> a := a ^ 5;
> repeat b := PseudoRandom(B); until Order(b) eq 15;
> b := b ^ 5;
> repeat b := b ^ PseudoRandom(B); ab := a*b;
> until Order(ab) eq 23;
> x := ab*(ab^2*b)^2*ab*b;
> if Order(x) eq 5 then b := b^-1; end if;
> return a,b;
> end function;
```
We take a group which must be $M_{24}$ and find these generators.
```magma
> G := PermutationGroup<24 |
> [ 20, 4, 10, 3, 15, 9, 7, 1, 11, 22, 21, 19, 8, 2, 24, 5,
> 12, 18, 13, 16, 14, 23, 6, 17 ],
> [ 12, 18, 3, 2, 7, 11, 5, 21, 19, 22, 23, 1, 14, 17, 10,
> 8, 4, 13, 24, 20, 9, 15, 6, 16 ]>;
> #G;
244823040
> Transitivity(G);
5
> B := NaturalBlackBoxGroup(G);
> a,b := m24_standard(B); a,b;
GrpBBElt (1, 16)(2, 22)(3, 14)(4, 15)(5, 11)(6, 24)(7,
10)(8, 18)(9, 19)(12, 17)(13, 20)(21, 23)
GrpBBElt (1, 14, 17)(2, 18, 13)(5, 16, 20)(7, 22, 9)(8, 24,
15)(19, 23, 21)
```
The printing of the GrpBBElts shows the underlying concrete group elements. These may be extracted using the `UnderlyingElement` intrinsic for use within $G$.
### Set-Theoretic Operations
#### Membership and Equality
##### `g in G: GrpBBElt, GrpBB -> BoolElt`
Return `true` if and only if $G$ is the parent group of $g$ or the parent group of $g$ is a subgroup of $G$.
#### Set Operations
##### `PseudoRandom(G): GrpBB -> GrpBBElt`
Return a pseudo-random element of the BB-group $G$. The method used is product-replacement with accumulator.
##### `Rep(G): GrpBB -> GrpBBElt`
A representative element of $G$.
#### Coercions Between Related Groups
##### `G ! g: GrpBB, GrpBBElt -> GrpBBElt`
Given an element $g$ belonging to a subgroup of the BB-group $G$, rewrite $g$ as an element of $G$.
## Almost Simple Groups
- [Introduction](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/introduction.md)
- [Overview](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/introduction.md#overview)
- [Double Covers of the Alternating and Symmetric Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/double-covers-alt-sym.md)
- [`DoubleCoverSymmetricGroup(n: parameters): RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/double-covers-alt-sym.md#function-doublecoversymmetricgroup-rngintelt)
- [`DoubleCoverAlternatingGroup(n: parameters): RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/double-covers-alt-sym.md#function-doublecoveralternatinggroup-rngintelt)
- [Creating Finite Groups of Lie Type](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md)
- [Generic Creation Function](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#generic-creation-function)
- [`ChevalleyGroup(X, n, K: parameters): MonStgElt, RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-chevalleygroup-monstgelt-rngintelt-fldfin)
- [`ChevalleyGroup(X, n, q: parameters): MonStgElt, RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-chevalleygroup-monstgelt-rngintelt-rngintelt)
- [The Orders of the Chevalley Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#the-orders-of-the-chevalley-groups)
- [`ChevalleyOrderPolynomial(type, n: parameters): MonStgElt, RngIntElt → RngUPolElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-chevalleyorderpolynomial-monstgelt-rngintelt)
- [`FactoredChevalleyGroupOrder(type, n, F: parameters): MonStgElt, RngIntElt, FldFin → RngIntEltFact`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-factoredchevalleygrouporder-monstgelt-rngintelt-fldfin)
- [`FactoredChevalleyGroupOrder(type, n, q: parameters): MonStgElt, RngIntElt, RngIntElt → RngIntEltFact`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-factoredchevalleygrouporder-monstgelt-rngintelt-rngintelt)
- [`ChevalleyGroupOrder(type, n, F: parameters): MonStgElt, RngIntElt, FldFin → RngIntEltFact`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-chevalleygrouporder-monstgelt-rngintelt-fldfin)
- [`ChevalleyGroupOrder(type, n, q: parameters): MonStgElt, RngIntElt, RngIntElt → RngIntEltFact`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-chevalleygrouporder-monstgelt-rngintelt-rngintelt)
- [Classical Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#classical-groups)
- [Linear Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#linear-groups)
- [`GeneralLinearGroup(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-generallineargroup)
- [`GeneralLinearGroup(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-generallineargroup-rngintelt-fldfin)
- [`GeneralLinearGroup(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-generallineargroup-modtuprng)
- [`GL(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-gl-rngintelt-rngintelt)
- [`GL(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-gl-rngintelt-fldfin)
- [`GL(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-gl-modtuprng)
- [`SpecialLinearGroup(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-speciallineargroup-rngintelt-rngintelt)
- [`SpecialLinearGroup(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-speciallineargroup-rngintelt-fldfin)
- [`SpecialLinearGroup(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-speciallineargroup-modtuprng)
- [`SL(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-sl-rngintelt-rngintelt)
- [`SL(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-sl-rngintelt-fldfin)
- [`SL(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-sl-modtuprng)
- [`AffineGeneralLinearGroup(GrpMat, n, q): Cat, RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-affinegenerallineargroup-cat-rngintelt-rngintelt)
- [`AffineGeneralLinearGroup(GrpMat, n, K): Cat, RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-affinegenerallineargroup-cat-rngintelt-fldfin)
- [`AffineGeneralLinearGroup(GrpMat, V): Cat, ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-affinegenerallineargroup-cat-modtuprng)
- [`AffineGeneralLinearGroup(E): GrpPerm → GrpPerm`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-affinegenerallineargroup-grpperm)
- [`AGL(GrpMat, n, q): Cat, RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-agl-cat-rngintelt-rngintelt)
- [`AGL(GrpMat, n, K): Cat, RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-agl-cat-rngintelt-fldfin)
- [`AGL(GrpMat, V): Cat, ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-agl-cat-modtuprng)
- [`AGL(E): GrpPerm → GrpPerm`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-agl-grpperm)
- [`AffineSpecialLinearGroup(GrpMat, n, q): Cat, RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-affinespeciallineargroup-cat-rngintelt-rngintelt)
- [`AffineSpecialLinearGroup(GrpMat, n, K): Cat, RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-affinespeciallineargroup-cat-rngintelt-fldfin)
- [`AffineSpecialLinearGroup(GrpMat, V): Cat, ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-affinespeciallineargroup-cat-modtuprng)
- [`ASL(GrpMat, n, q): Cat, RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-asl-cat-rngintelt-rngintelt)
- [`ASL(GrpMat, n, K): Cat, RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-asl-cat-rngintelt-fldfin)
- [`ASL(GrpMat, V): Cat, ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-asl-cat-modtuprng)
- [Unitary Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#unitary-groups)
- [`ConformalUnitaryGroup(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalunitarygroup)
- [`ConformalUnitaryGroup(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalunitarygroup-rngintelt-fldfin)
- [`ConformalUnitaryGroup(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalunitarygroup-modtuprng)
- [`CU(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-cu-rngintelt-rngintelt)
- [`CU(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-cu-rngintelt-fldfin)
- [`CU(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-cu-modtuprng)
- [`GeneralUnitaryGroup(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-generalunitarygroup-rngintelt-rngintelt)
- [`GeneralUnitaryGroup(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-generalunitarygroup-rngintelt-fldfin)
- [`GeneralUnitaryGroup(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-generalunitarygroup-modtuprng)
- [`GU(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-gu-rngintelt-rngintelt)
- [`GU(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-gu-rngintelt-fldfin)
- [`GU(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-gu-modtuprng)
- [`SpecialUnitaryGroup(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-specialunitarygroup-rngintelt-rngintelt)
- [`SpecialUnitaryGroup(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-specialunitarygroup-rngintelt-fldfin)
- [`SpecialUnitaryGroup(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-specialunitarygroup-modtuprng)
- [`SU(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-su-rngintelt-rngintelt)
- [`SU(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-su-rngintelt-fldfin)
- [`SU(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-su-modtuprng)
- [`ConformalSpecialUnitaryGroup(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalspecialunitarygroup-rngintelt-rngintelt)
- [`CSU(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-csu-rngintelt-rngintelt)
- [Symplectic Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#symplectic-groups)
- [`ConformalSymplecticGroup(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalsymplecticgroup-rngintelt-rngintelt)
- [`ConformalSymplecticGroup(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalsymplecticgroup-rngintelt-fldfin)
- [`ConformalSymplecticGroup(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalsymplecticgroup-modtuprng)
- [`CSp(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-csp-rngintelt-rngintelt)
- [`CSp(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-csp-rngintelt-fldfin)
- [`CSp(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-csp-modtuprng)
- [`SymplecticGroup(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-symplecticgroup-rngintelt-rngintelt)
- [`SymplecticGroup(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-symplecticgroup-rngintelt-fldfin)
- [`SymplecticGroup(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-symplecticgroup-modtuprng)
- [`Sp(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-sp-rngintelt-rngintelt)
- [`Sp(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-sp-rngintelt-fldfin)
- [`Sp(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-sp-modtuprng)
- [Orthogonal and Spin Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#orthogonal-and-spin-groups)
- [`ConformalOrthogonalGroup(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalorthogonalgroup-rngintelt-rngintelt)
- [`ConformalOrthogonalGroup(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalorthogonalgroup-rngintelt-fldfin)
- [`ConformalOrthogonalGroup(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalorthogonalgroup-modtuprng)
- [`CO(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-co-rngintelt-rngintelt)
- [`CO(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-co-rngintelt-fldfin)
- [`CO(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-co-modtuprng)
- [`GeneralOrthogonalGroup(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-generalorthogonalgroup-rngintelt-rngintelt)
- [`GeneralOrthogonalGroup(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-generalorthogonalgroup-rngintelt-fldfin)
- [`GeneralOrthogonalGroup(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-generalorthogonalgroup-modtuprng)
- [`GO(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-go-rngintelt-rngintelt)
- [`GO(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-go-rngintelt-fldfin)
- [`GO(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-go-modtuprng)
- [Example: Orthogonal Group in Odd Dimension](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#example-ex-681a40)
- [`SpecialOrthogonalGroup(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-specialorthogonalgroup-rngintelt-rngintelt)
- [`SpecialOrthogonalGroup(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-specialorthogonalgroup-rngintelt-fldfin)
- [`SpecialOrthogonalGroup(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-specialorthogonalgroup-modtuprng)
- [`SO(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-so-rngintelt-rngintelt)
- [`SO(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-so-rngintelt-fldfin)
- [`SO(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-so-modtuprng)
- [`ConformalSpecialOrthogonalGroup(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalspecialorthogonalgroup-rngintelt-rngintelt)
- [`CSO(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-cso-rngintelt-rngintelt)
- [`ConformalOrthogonalGroupPlus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalorthogonalgroupplus-rngintelt-rngintelt)
- [`ConformalOrthogonalGroupPlus(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalorthogonalgroupplus-rngintelt-fldfin)
- [`ConformalOrthogonalGroupPlus(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalorthogonalgroupplus-modtuprng)
- [`COPlus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-coplus-rngintelt-rngintelt)
- [`COPlus(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-coplus-rngintelt-fldfin)
- [`COPlus(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-coplus-modtuprng)
- [`GeneralOrthogonalGroupPlus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-generalorthogonalgroupplus-rngintelt-rngintelt)
- [`GeneralOrthogonalGroupPlus(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-generalorthogonalgroupplus-rngintelt-fldfin)
- [`GeneralOrthogonalGroupPlus(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-generalorthogonalgroupplus-modtuprng)
- [`GOPlus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-goplus-rngintelt-rngintelt)
- [`GOPlus(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-goplus-rngintelt-fldfin)
- [`GOPlus(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-goplus-modtuprng)
- [`SpecialOrthogonalGroupPlus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-specialorthogonalgroupplus-rngintelt-rngintelt)
- [`SpecialOrthogonalGroupPlus(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-specialorthogonalgroupplus-rngintelt-fldfin)
- [`SpecialOrthogonalGroupPlus(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-specialorthogonalgroupplus-modtuprng)
- [`SOPlus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-soplus-rngintelt-rngintelt)
- [`SOPlus(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-soplus-rngintelt-fldfin)
- [`SOPlus(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-soplus-modtuprng)
- [`ConformalSpecialOrthogonalGroupPlus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalspecialorthogonalgroupplus-rngintelt-rngintelt)
- [`CSOPlus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-csoplus-rngintelt-rngintelt)
- [`ConformalOrthogonalGroupMinus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalorthogonalgroupminus-rngintelt-rngintelt)
- [`ConformalOrthogonalGroupMinus(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalorthogonalgroupminus-rngintelt-fldfin)
- [`ConformalOrthogonalGroupMinus(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalorthogonalgroupminus-modtuprng)
- [`COMinus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-cominus-rngintelt-rngintelt)
- [`COMinus(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-cominus-rngintelt-fldfin)
- [`COMinus(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-cominus-modtuprng)
- [`GeneralOrthogonalGroupMinus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-generalorthogonalgroupminus-rngintelt-rngintelt)
- [`GeneralOrthogonalGroupMinus(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-generalorthogonalgroupminus-rngintelt-fldfin)
- [`GeneralOrthogonalGroupMinus(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-generalorthogonalgroupminus-modtuprng)
- [`GOMinus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-gominus-rngintelt-rngintelt)
- [`GOMinus(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-gominus-rngintelt-fldfin)
- [`GOMinus(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-gominus-modtuprng)
- [`SpecialOrthogonalGroupMinus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-specialorthogonalgroupminus-rngintelt-rngintelt)
- [`SpecialOrthogonalGroupMinus(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-specialorthogonalgroupminus-rngintelt-fldfin)
- [`SpecialOrthogonalGroupMinus(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-specialorthogonalgroupminus-modtuprng)
- [`SOMinus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-sominus-rngintelt-rngintelt)
- [`SOMinus(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-sominus-rngintelt-fldfin)
- [`SOMinus(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-sominus-modtuprng)
- [`ConformalSpecialOrthogonalGroupMinus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-conformalspecialorthogonalgroupminus-rngintelt-rngintelt)
- [`CSOMinus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-csominus-rngintelt-rngintelt)
- [`Omega(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-omega-rngintelt-rngintelt)
- [`Omega(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-omega-rngintelt-fldfin)
- [`Omega(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-omega-modtuprng)
- [`OmegaPlus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-omegaplus-rngintelt-rngintelt)
- [`OmegaPlus(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-omegaplus-rngintelt-fldfin)
- [`OmegaPlus(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-omegaplus-modtuprng)
- [`OmegaMinus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-omegaminus-rngintelt-rngintelt)
- [`OmegaMinus(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-omegaminus-rngintelt-fldfin)
- [`OmegaMinus(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-omegaminus-modtuprng)
- [`Spin(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-spin-rngintelt-rngintelt)
- [`Spin(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-spin-rngintelt-fldfin)
- [`Spin(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-spin-modtuprng)
- [`SpinPlus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-spinplus-rngintelt-rngintelt)
- [`SpinPlus(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-spinplus-rngintelt-fldfin)
- [`SpinPlus(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-spinplus-modtuprng)
- [`SpinMinus(n, q): RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-spinminus-rngintelt-rngintelt)
- [`SpinMinus(n, K): RngIntElt, FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-spinminus-rngintelt-fldfin)
- [`SpinMinus(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-spinminus-modtuprng)
- [Exceptional Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#exceptional-groups)
- [Suzuki Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#suzuki-groups)
- [`SuzukiGroup(q): RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-suzukigroup-rngintelt)
- [`SuzukiGroup(K): FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-suzukigroup-fldfin)
- [`SuzukiGroup(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-suzukigroup-modtuprng)
- [Example: Symplectic Group of Dimension 10](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#example-ex-df72cd)
- [Example: Creating a Suzuki Group](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#example-ex-58f4ed)
- [Small Ree Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#small-ree-groups)
- [`ReeGroup(q): RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-reegroup-rngintelt)
- [`ReeGroup(K): FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-reegroup-fldfin)
- [`ReeGroup(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-reegroup-modtuprng)
- [Large Ree Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#large-ree-groups)
- [`LargeReeGroup(q): RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-largereegroup-rngintelt)
- [`LargeReeGroup(K): FldFin → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-largereegroup-fldfin)
- [`LargeReeGroup(V): ModTupRng → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/standard.md#function-largereegroup-modtuprng)
- [Group Recognition](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md)
- [Constructive Recognition of Alternating Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#constructive-recognition-of-alternating-groups)
- [`RecogniseAlternatingOrSymmetric(G : parameters): Grp, RngIntElt → BoolElt, Map, Map, Map, Map, BoolElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognisealternatingorsymmetric-grp-rngintelt)
- [`AlternatingOrSymmetricElementToWord(G, g): Grp, GrpElt → BoolElt, GrpSLPElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-alternatingorsymmetricelementtoword-grp-grpelt)
- [Example: Recognising a Representation of A13](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#example-ex-98afe7)
- [`RecogniseSymmetric(G, n: parameters): Grp, RngIntElt → BoolElt, Map, Map, Map, Map, BoolElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognisesymmetric-grp-rngintelt)
- [`SymmetricElementToWord(G, g): Grp, GrpElt → BoolElt, GrpSLPElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-symmetricelementtoword-grp-grpelt)
- [`RecogniseAlternating(G, n: parameters): Grp, RngIntElt → BoolElt, Map, Map, Map, Map, BoolElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognisealternating-grp-rngintelt)
- [`AlternatingElementToWord(G, g): Grp, GrpElt → BoolElt, GrpSLPElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-alternatingelementtoword-grp-grpelt)
- [`GuessAltsymDegree(G: parameters): Grp → BoolElt, MonStgElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-guessaltsymdegree-grp)
- [Example: Guessing the Degree of an Alternating Group](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#example-ex-785664)
- [Determining the Type of a Finite Group of Lie Type](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#determining-the-type-of-a-finite-group-of-lie-type)
- [`LieCharacteristic(G : parameters): Grp → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-liecharacteristic-grp)
- [Example: Characteristic of a Group of Lie Type](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#example-ex-337eef)
- [`LieType(G, p : parameters): GrpMat, RngIntElt → BoolElt, Tup`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-grpmatff-lietype)
- [`LieType(G, p : parameters): GrpMat, RngIntElt → BoolElt, Tup`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-grpperm-lietype)
- [`SimpleGroupName(G : parameters): GrpMat → BoolElt, List`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-simplegroupname-grpmat)
- [`SimpleGroupName(G : parameters): GrpPerm → BoolElt, List`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-simplegroupname-grpperm)
- [Example: Naming a Simple Group](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#example-ex-ffaa04)
- [Classical Forms](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#classical-forms)
- [`ClassicalForms(G: parameters): GrpMat → Rec`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-grpmat-classicalforms)
- [`SymplecticForm(G: parameters): GrpMat → BoolElt, AlgMatElt [,SeqEnum]`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-symplecticform-grpmat)
- [`SymmetricBilinearForm(G: parameters): GrpMat → BoolElt, AlgMatElt, MonStgElt [,SeqEnum]`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-symmetricbilinearform-grpmat)
- [`QuadraticForm(G): GrpMat → BoolElt, AlgMatElt, MonStgElt [,SeqEnum]`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-quadraticform-grpmat)
- [`UnitaryForm(G): GrpMat → BoolElt, AlgMatElt [,SeqEnum]`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-unitaryform-grpmat)
- [`FormType(G): GrpMat → MonStgElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-formtype-grpmat)
- [Example: Classical Forms of an Orthogonal Group](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#example-ex-9382cf)
- [`TransformForm(form, type): AlgMatElt, MonStgElt → GrpMatElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-transformform-algmatelt-monstgelt)
- [`TransformForm(G): GrpMat → GrpMatElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-transformform-grpmat)
- [`SpinorNorm(g, form): GrpMatElt, AlgMatElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-spinornorm-grpmatelt-algmatelt)
- [Example: Spinor Norm in an Orthogonal Group](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#example-ex-b5d734)
- [Recognizing Classical Groups in their Natural Representation](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#recognizing-classical-groups-in-their-natural-representation)
- [`RecognizeClassical(G : parameters): GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognizeclassical-grpmat)
- [`RecogniseClassical(G : parameters): GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recogniseclassical-grpmat)
- [`IsLinearGroup(G): GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-islineargroup)
- [`IsSymplecticGroup(G): GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-issymplecticgroup-grpmat)
- [`IsOrthogonalGroup(G): GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-isorthogonalgroup-grpmat)
- [`IsUnitaryGroup(G): GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-isunitarygroup-grpmat)
- [`ClassicalType(G): GrpMat → MonStgElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-classicaltype-grpmat)
- [`ClassicalGroupType(G): GrpMat → BoolElt, MonStgElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-classicalgrouptype-grpmat)
- [Example: Recognising a Unitary Group](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#example-ex-9f3ea6)
- [Constructive Recognition of Linear Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#constructive-recognition-of-linear-groups)
- [`RecognizeSL2(G): GrpMat → BoolElt, Map, Map, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognizesl2-grpmat)
- [`RecogniseSL2(G): GrpMat → BoolElt, Map, Map, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognisesl2-grpmat)
- [`RecognizeSL2(G): GrpPerm → BoolElt, Map, Map, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognizesl2-grpperm)
- [`RecogniseSL2(G): GrpPerm → BoolElt, Map, Map, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognisesl2-grpperm)
- [`RecognizeSL2(G, q): GrpMat, RngIntElt → BoolElt, Map, Map, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognizesl2-grpmat-rngintelt)
- [`RecogniseSL2(G, q): GrpMat, RngIntElt → BoolElt, Map, Map, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognisesl2-grpmat-rngintelt)
- [`RecognizeSL2(G, q): GrpPerm, RngIntElt → BoolElt, Map, Map, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognizesl2-grpperm-rngintelt)
- [`RecogniseSL2(G, q): GrpPerm, RngIntElt → BoolElt, Map, Map, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognisesl2-grpperm-rngintelt)
- [`SL2ElementToWord(G, g): GrpMat, GrpMatElt → BoolElt, GrpSLPElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-sl2elementtoword-grpmat-grpmatelt)
- [`SL2ElementToWord(G, g): GrpPerm, GrpPermElt → BoolElt, GrpSLPElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-sl2elementtoword-grpperm-grppermelt)
- [`SL2Characteristic(G : parameters): GrpMat → RngIntElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-sl2characteristic-grpmat)
- [`SL2Characteristic(G : parameters): GrpPerm → RngIntElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-sl2characteristic-grpperm)
- [Example: Recognising SL2 in Its Natural Representation](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#example-ex-6829cc)
- [Example: Recognising SL2 in Dimension 6](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#example-ex-82f78a)
- [`RecogniseSL3(G): GrpMat → BoolElt, Map, Map, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognisesl3-grpmat)
- [`RecogniseSL3(G, q : parameters): GrpMat, RngIntElt → BoolElt, Map, Map, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognisesl3-grpmat-rngintelt)
- [`SL3ElementToWord(G, g): GrpMat, GrpMatElt → BoolElt, GrpSLPElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-sl3elementtoword-grpmat-grpmatelt)
- [Example: Recognising SL3 and Its Symmetric Square](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#example-ex-46bbe9)
- [`RecogniseSL(G, d, q): Grp, RngIntElt, RngIntElt → BoolElt, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognisesl-grp-rngintelt-rngintelt)
- [`RecognizeSL(G, d, q): Grp, RngIntElt, RngIntElt → BoolElt, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognizesl-grp-rngintelt-rngintelt)
- [Constructive Recognition of Symplectic Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#constructive-recognition-of-symplectic-groups)
- [`RecogniseSpOdd(G, d, q): Grp, RngIntElt, RngIntElt → BoolElt, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognisespodd-grp-rngintelt-rngintelt)
- [`RecognizeSpOdd(G, d, q): Grp, RngIntElt, RngIntElt → BoolElt, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognizespodd-grp-rngintelt-rngintelt)
- [`RecogniseSp4(G, q): Grp, RngIntElt, RngIntElt → BoolElt, Map, Map, Map, Map, SeqEnum, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognisesp4-grp-rngintelt-rngintelt)
- [`RecognizeSp4(G, q): Grp, RngIntElt, RngIntElt → BoolElt, Map, Map, Map, Map, SeqEnum, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognizesp4-grp-rngintelt-rngintelt)
- [Constructive Recognition of Unitary Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#constructive-recognition-of-unitary-groups)
- [`RecogniseSU3(G, d, q): Grp, RngIntElt, RngIntElt → BoolElt, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognisesu3-grp-rngintelt-rngintelt)
- [`RecognizeSU3(G, d, q): Grp, RngIntElt, RngIntElt → BoolElt, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognizesu3-grp-rngintelt-rngintelt)
- [`RecogniseSU4(G, d, q): Grp, RngIntElt, RngIntElt → BoolElt, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognisesu4-grp-rngintelt-rngintelt)
- [`RecognizeSU4(G, d, q): Grp, RngIntElt, RngIntElt → BoolElt, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognizesu4-grp-rngintelt-rngintelt)
- [Recognition Of Classical Groups in Low Degree](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#recognition-of-classical-groups-in-low-degree)
- [`RecogniseSmallDegree(G): GrpMat → BoolElt, GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognisesmalldegree-grpmat)
- [`RecogniseSmallDegree(G, type, d, q): GrpMat, MonStgElt, RngIntElt, RngIntElt → BoolElt, GrpMat, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognisesmalldegree-grpmat-monstgelt-rngintelt-rngintelt)
- [`SmallDegreePreimage(G, g): GrpMat, GrpMatElt → GrpMatElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-smalldegreepreimage-grpmat-grpmatelt)
- [`SmallDegreeImage(G, h): GrpMat, GrpMatElt → GrpMatElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-smalldegreeimage-grpmat-grpmatelt)
- [Example: Recognising SL4 in a Symmetric Square](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#example-ex-5df193)
- [Constructive Recognition of Suzuki Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#constructive-recognition-of-suzuki-groups)
- [Introduction](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#introduction)
- [Recognition Functions](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#recognition-functions)
- [`IsSuzukiGroup(G): GrpMat → BoolElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-issuzukigroup-grpmat)
- [`RecogniseSz(G : parameters): GrpMat → BoolElt, Map, Map, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognisesz-grpmat)
- [`RecognizeSz(G : parameters): GrpMat → BoolElt, Map, Map, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognizesz-grpmat)
- [`SzElementToWord(G, g): GrpMat, GrpMatElt → BoolElt, GrpSLPElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-szelementtoword-grpmat-grpmatelt)
- [`SzPresentation(q): RngIntElt → GrpFP, HomGrp`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-szpresentation-rngintelt)
- [`SatisfiesSzPresentation(G): GrpMat → BoolElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-satisfiesszpresentation-grpmat)
- [`SuzukiIrreducibleRepresentation(F, twists : parameters): FldFin, SeqEnum[RngIntElt] → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-suzukiirreduciblerepresentation-fldfin-seqenum-rngintelt)
- [Example: Recognising the Suzuki Group Sz(32)](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#example-ex-9d33f6)
- [Example: Constructive Membership in 2.Sz(8)](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#example-ex-d3b056)
- [Example: Suzuki Group in Dimension 64](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#example-ex-f8d565)
- [Example: Suzuki Group in Cross Characteristic](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#example-ex-183108)
- [Constructive Recognition of Small Ree Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#constructive-recognition-of-small-ree-groups)
- [Introduction](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#id29)
- [Recognition Functions](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#id30)
- [`RecogniseRee(G : parameters): GrpMat → BoolElt, Map, Map, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recogniseree-grpmat)
- [`RecognizeRee(G : parameters): GrpMat → BoolElt, Map, Map, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognizeree-grpmat)
- [`ReeElementToWord(G, g): GrpMat, GrpMatElt → BoolElt, GrpSLPElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-reeelementtoword-grpmat-grpmatelt)
- [`IsReeGroup(G): GrpMat → BoolElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-isreegroup-grpmat)
- [`ReeIrreducibleRepresentation(F, twists : parameters): FldFin, SeqEnum[RngIntElt] → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-reeirreduciblerepresentation-fldfin-seqenum-rngintelt)
- [Example: Recognising a Ree Group](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#example-ex-79d9a3)
- [Constructive Recognition of Large Ree Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#constructive-recognition-of-large-ree-groups)
- [Introduction](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#id32)
- [Recognition Functions](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#id33)
- [`RecogniseLargeRee(G : parameters): GrpMat → BoolElt, Map, Map, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recogniselargeree-grpmat)
- [`RecognizeLargeRee(G : parameters): GrpMat → BoolElt, Map, Map, Map, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-recognizelargeree-grpmat)
- [`LargeReeElementToWord(G, g): GrpMat, GrpMatElt → BoolElt, GrpSLPElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-largereeelementtoword-grpmat-grpmatelt)
- [`IsLargeReeGroup(G): GrpMat → BoolElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-islargereegroup-grpmat)
- [Properties of Finite Groups Of Lie Type](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md)
- [Maximal Subgroups of the Classical Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#maximal-subgroups-of-the-classical-groups)
- [`ClassicalMaximals(type, d, q : parameters): MonStgElt, RngIntElt, RngIntElt → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-classicalmaximals-monstgelt-rngintelt-rngintelt)
- [Maximal Subgroups of the Exceptional Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#maximal-subgroups-of-the-exceptional-groups)
- [`SuzukiMaximalSubgroups(G): GrpMat → SeqEnum, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-suzukimaximalsubgroups-grpmat)
- [`SuzukiMaximalSubgroupsConjugacy(G, R, S): GrpMat, GrpMat, GrpMat → GrpMatElt, GrpSLPElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-suzukimaximalsubgroupsconjugacy-grpmat-grpmat-grpmat)
- [`ReeMaximalSubgroups(G): GrpMat → SeqEnum, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-reemaximalsubgroups-grpmat)
- [`ReeMaximalSubgroupsConjugacy(G, R, S): GrpMat, GrpMat, GrpMat → GrpMatElt, GrpSLPElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-reemaximalsubgroupsconjugacy-grpmat-grpmat-grpmat)
- [`SzMaximals(q): RngIntElt → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-szmaximals-rngintelt)
- [`ReeMaximals(q): RngIntElt → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-reemaximals-rngintelt)
- [`G2Maximals(q): RngIntElt → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-g2maximals-rngintelt)
- [Sylow Subgroups of the Classical Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#sylow-subgroups-of-the-classical-groups)
- [`ClassicalSylow(G,p): GrpMat, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-classicalsylow-grpmat-rngintelt)
- [`ClassicalSylowConjugation(G,P,S): GrpMat, GrpMat, GrpMat → GrpMatElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-classicalsylowconjugation-grpmat-grpmat-grpmat)
- [`ClassicalSylowNormaliser(G,P): GrpMat, GrpMat → GrpMatElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-classicalsylownormaliser-grpmat-grpmat)
- [`ClassicalSylowToPC(G,P): GrpMat, GrpMat → GrpPC, UserProgram, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-classicalsylowtopc-grpmat-grpmat)
- [Example: Sylow Subgroups of a Symplectic Group](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#example-ex-464f7f)
- [Sylow Subgroups of Exceptional Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#sylow-subgroups-of-exceptional-groups)
- [`SuzukiSylow(G, p): GrpMat, RngIntElt → GrpMat, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-suzukisylow-grpmat-rngintelt)
- [`SuzukiSylowConjugacy(G, R, S, p): GrpMat, GrpMat, GrpMat, RngIntElt → GrpMatElt, GrpSLPElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-suzukisylowconjugacy-grpmat-grpmat-grpmat-rngintelt)
- [Example: Sylow Subgroups of a Large Suzuki Group](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#example-ex-c86d0c)
- [`ReeSylow(G, p): GrpMat, RngIntElt → GrpMat, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-reesylow-grpmat-rngintelt)
- [`ReeSylowConjugacy(G, R, S, p): GrpMat, GrpMat, GrpMat, RngIntElt → GrpMatElt, GrpSLPElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-reesylowconjugacy-grpmat-grpmat-grpmat-rngintelt)
- [`LargeReeSylow(G, p): GrpMat, RngIntElt → GrpMat, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-largereesylow-grpmat-rngintelt)
- [Example: Sylow Subgroups of a Ree Group](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#example-ex-026da0)
- [Conjugacy of Subgroups of the Classical Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#conjugacy-of-subgroups-of-the-classical-groups)
- [`IsGLConjugate(H, K): GrpMat, GrpMat → BoolElt, GrpMatElt | Unass`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-isglconjugate-grpmat-grpmat)
- [Conjugacy of Elements of the Exceptional Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#conjugacy-of-elements-of-the-exceptional-groups)
- [`SzConjugacyClasses(G): GrpMat → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-szconjugacyclasses-grpmat)
- [`SzClassRepresentative(G, g): GrpMat, GrpMatElt → GrpMatElt, GrpMatElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-szclassrepresentative-grpmat-grpmatelt)
- [`SzIsConjugate(G, g, h): GrpMat, GrpMatElt, GrpMatElt → BoolElt, GrpMatElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-szisconjugate-grpmat-grpmatelt-grpmatelt)
- [`SzClassMap(G): GrpMat → Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-szclassmap-grpmat)
- [`ReeConjugacyClasses(G): GrpMat → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-reeconjugacyclasses-grpmat)
- [Irreducible Subgroups of the General Linear Group](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#irreducible-subgroups-of-the-general-linear-group)
- [`IrreducibleSubgroups(n, q): RngIntElt, RngIntElt → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#function-irreduciblesubgroups-rngintelt-rngintelt)
- [Example: Counting Irreducible Matrix Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/properties-lie-groups.md#example-ex-4bbc80)
- [Atlas Data for the Sporadic Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/related.md)
- [`StandardGenerators(G, str : parameters): Grp, MonStgElt → BoolElt, SeqEnum, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/related.md#function-standardgenerators-grp-monstgelt)
- [`StandardGeneratorsGroupNames() → SetIndx`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/related.md#function-standardgeneratorsgroupnames)
- [`StandardCopy(str): MonStgElt → Grp, BoolElt`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/related.md#function-standardcopy-monstgelt)
- [`IsomorphismToStandardCopy(G, str : parameters): Grp, MonStgElt → BoolElt, Map`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/related.md#function-isomorphismtostandardcopy-grp-monstgelt)
- [`StandardPresentation(G, str : parameters): Grp, MonStgElt → BoolElt, SeqEnum, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/related.md#function-standardpresentation-grp-monstgelt)
- [`MaximalSubgroups(G, str : parameters): Grp, MonStgElt → BoolElt, SeqEnum, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/related.md#function-maximalsubgroups-grp-monstgelt)
- [`Subgroups(G, str : parameters): Grp, MonStgElt → BoolElt, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/related.md#function-subgroups-grp-monstgelt)
- [`GoodBasePoints(G, str : parameters): Grp, MonStgElt → BoolElt, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/related.md#function-goodbasepoints-grp-monstgelt)
- [`SubgroupsData(str): MonStgElt → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/related.md#function-subgroupsdata-monstgelt)
- [`MaximalSubgroupsData(str : parameters): MonStgElt → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/related.md#function-maximalsubgroupsdata-monstgelt)
- [Example: Atlas Data for the Janko Group J1](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/related.md#example-ex-328794)
- [Automorphism Groups of Finite Simple Groups](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/autgpsimgpss.md)
- [`AutomorphismGroupSimpleGroup(type, d, q): MonStgElt, RngIntElt, RngIntElt → GrpPerm`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/autgpsimgpss.md#function-automorphismgroupsimplegroup-monstgelt-rngintelt-rngintelt)
- [`AutomorphismGroupSimpleGroup(type, q): MonStgElt, RngIntElt → GrpPerm`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/autgpsimgpss.md#function-automorphismgroupsimplegroup-monstgelt-rngintelt)
- [`AutomorphismGroupSimpleGroup(name): MonStgElt → GrpPerm`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/autgpsimgpss.md#function-automorphismgroupsimplegroup-monstgelt)
- [`AutomorphismGroupSimpleGroup(triple): Tup → GrpPerm`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/autgpsimgpss.md#function-automorphismgroupsimplegroup-tup)
- [Bibliography](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/bibliography.md)
### Introduction
#### Overview
This chapter describes a set of tools for working with finite almost-simple groups (AS-groups). In the program for computing with non-soluble finite groups, the goal is to reduce the solution of many problems concerning a non-soluble group $G$ to that of solving the same problem for the non-abelian simple composition factors of $G$. We are concerned with very specific types of computation with AS-groups.
The techniques described in this chapter are under development and are very incomplete in their coverage. The material falls roughly into two main categories.
**(a)**
Functions which try to identify a particular group $S$ known to be almost simple with a standard copy $T$ of that AS-group. In addition, if such an isomorphism is found, it is often desirable to explicitly construct it so that questions concerning $S$ can be answered by mapping them into the “standard” group $T$. Hence the recognition functions are divided into those which perform *non-constructive recognition* (they assert the existence of an isomorphism between $S$ and $T$) and those that perform *constructive recognition* (an explicit isomorphism between $S$ and $T$ is returned).
**(b)**
Functions which allow the user to determine information about an AS-group. These functions are usually implemented separately for each family of simple groups. Thus, for each family of simple groups our goal is to provide machinery for constructing key properties of any group $T$ in that family in the context of a standard representation of the group. Using the isomorphism constructed in (a), this information can then be transferred back to the user’s group $S$. Examples of such information include, information about element conjugacy, maximal subgroups, and Sylow $p$-subgroups.
The functions described in this chapter do not assume that a BSGS-representation can be constructed available. Thus, the techniques described here apply to groups possibly having both much larger order and/or much larger dimension than those that can be handled with the techniques of Chapters [Permutation Groups](https://docs.magma-maths.org/FiniteGroups/PermutationGroups/index-permutation-groups.md#chapgrpperm) and [Matrix Groups over General Rings](https://docs.magma-maths.org/FiniteGroups/MatrixGroupsOverGeneralRings/index-matrix-groups-over-general-rings.md#chapgrpmat).
### Double Covers of the Alternating and Symmetric Groups
These functions construct representations of the groups $2A_n$ and $2S_n$ as matrix groups over a field ${\bf F}_{p}$ or (usually) ${\bf F}_{p^2}$ for an odd prime $p$. Their dimension is $2^d$ with $d = (n-1)/2,\, (n-2)/2$, or $(n-3)/2$ depending on $n \bmod 6$. The method used is described in [[Maa09](https://docs.magma-maths.org/references.md#cite-maas)].
#### `DoubleCoverSymmetricGroup(n: parameters): RngIntElt -> GrpMat`
```magma
Sign : MonStgElt Default: "-"
Characteristic: RngIntElt Default: 3
```
The double cover $2S_n$ of the symmetric groups $S_n$ of degree $n$ for $n \ge 4$ represented as a matrix group over the field ${\bf F}_{p}$ or (usually) ${\bf F}_{p^2}$, where $p$, which defaults to $3$, can be specified as `Characteristic`.
There are two isomorphism classes of groups with this structure, which are distinguished by the optional parameter `Sign`, which can be positive, (`Sign` = “+” or “plus”), or (default) negative (`Sign` = “-” or “minus”). The inverse images of the Coxeter generators of $S_n$ have order $2$ when `Sign` is “+” and $4$ when `Sign` is “-“.
#### `DoubleCoverAlternatingGroup(n: parameters): RngIntElt -> GrpMat`
```magma
Characteristic: RngIntElt Default: 3
```
The double cover $2A_n$ of the symmetric groups $A_n$ of degree $n$ for $n \ge 4$ represented as a matrix group over the field ${\bf F}_{p}$ or (usually) ${\bf F}_{p^2}$, where $p$, which defaults to $3$, can be specified as `Characteristic`.
### Creating Finite Groups of Lie Type
Several functions are provided which construct various classical groups and other groups of Lie type. The effect of these functions is to define the group in terms of a set of generating matrices.
As shown by Chevalley, for each simple Lie algebra $L$ over the complex field and for each finite field ${\bf F}_{q}$ there is an associated matrix group $L(q)$. In general, these groups are perfect but not simple. To obtain the simple group, it is necessary to form the quotient by the centre. Similarly, as Steinberg, Ree, and others have shown, if the associated Coxeter graph has an automorphism, of order $t$ say, then there will be a ‘twisted’ version ${}^tL(q)$ of $L(q)$.
Generators for the series A, C, ${}^2$A, and ${}^2$B are described in [[Tay87](https://docs.magma-maths.org/references.md#cite-taylor)]. Generators for the series B, D, and ${}^2$D are as given by Rylands and Taylor [[RT98](https://docs.magma-maths.org/references.md#cite-rylands-taylor)]. Generators for the exceptional groups of Lie type are described by Howlett, Rylands, and Taylor in [[HRT01](https://docs.magma-maths.org/references.md#cite-howlett-rylands-taylor)].
#### Generic Creation Function
##### `ChevalleyGroup(X, n, K: parameters): MonStgElt, RngIntElt, FldFin -> GrpMat`
##### `ChevalleyGroup(X, n, q: parameters): MonStgElt, RngIntElt, RngIntElt -> GrpMat`
```magma
Irreducible: BoolElt Default: false
```
Construct a matrix group over the field $K$ (or over ${\bf F}_{q}$) which has the adjoint Chevalley group of Lie series `X` and Lie rank $n$ as the quotient modulo scalar matrices. In most cases the group returned is the universal Chevalley group $X_n(q)$; however, for series `B`, `D`, and `2D` the universal group is the spin group and the matrix group returned by `ChevalleyGroup` is $\Omega(2n+1,q)$, $\Omega^+(2n,q)$, or $\Omega^-(2n,q)$.
For the twisted groups the meaning of the parameter $q$ is consistent with the (abbreviated) notation in the ‘Atlas of Finite Groups’ and in the monograph series ‘The Classification of the Finite Simple Groups’ by Gorenstein, Lyons, and Solomon. For a Chevalley group of rank $n$ and type $X$ with an automorphism of order $t$ the Atlas defines the *twisted Chevalley group* ${}^tX_n(q,q^t)$ to be the set of elements of $X_n(q^t)$ fixed by the quotient of the twisting automorphism and the field automorphism induced by $x \mapsto x^q$ of ${\bf F}_{q^t}$. In the Atlas the abbreviated notation for the twisted group is ${}^tX_n(q)$ but in Carter [[Car72a](https://docs.magma-maths.org/references.md#cite-car72)] it is ${}^tX_n(q^t)$. The first signature of the intrinsic expects the field ${\bf F}_{q^t}$ but the second signature expects the parameter $q$.
For example, for the series `"2A"`, the group ${}^2A_n(q)$ is ${\operatorname{SU}}(n + 1, q)$ but, in the first form of the signature, $K$ must be the field ${\bf F}_{q^2}$. Similarly the first form of the signature for the groups ${}^3D_4(q)$ and ${}^2E_6(q)$ requires the fields ${\bf F}_{q^3}$ and ${\bf F}_{q^2}$, respectively.
The possible series and the groups returned are:
**`"A"`**
$n\geq 0$, $A_n(q)$, the special linear group ${\operatorname{SL}}(n + 1, q)$.
**`"B"`**
$n\geq 1$, $B_n(q)$, the orthogonal group $\Omega(2n + 1, q)$.
**`"C"`**
$n\geq 1$, $C_n(q)$, the symplectic group ${\operatorname{Sp}}(2n, q)$.
**`"D"`**
$n\geq 1$, $D_n(q)$, the orthogonal group $\Omega^+(2n, q)$.
**`"E"`**
$n\in\lbrace6,7,8\rbrace$, the exceptional groups $E_n(q)$. $E_6(q)$ is represented as a matrix group of degree 27. It is simple unless $q\equiv 1\bmod 3$, in which case its centre has order 3. $E_7(q)$ is represented as a matrix group of degree 56. It is simple unless $q\equiv 1\bmod 2$, in which case its centre has order 2. $E_8(q)$ is represented as a matrix group of degree $248$.
**`"F"`**
$n = 4$, the exceptional group $F_4(q)$ represented as a matrix group of degree 26. If $q = 3^k$ then this representation is reducible. An irreducible representation is not yet available.
**`"G"`**
$n = 2$, the exceptional group $G_2(q)$ represented as a matrix group of degree 7. If $q = 2^k$ then this representation is reducible. An irreducible representation of degree 6 can be obtained by setting the parameter `Irreducible := true`.
**`"2A"`**
$n\geq 1$, $K = {\bf F}_{q^2}$, the special unitary group ${}^2A_n(q) = {\operatorname{SU}}(n + 1, q)$.
**`"2B"`**
$n = 2$, $K = {\bf F}_{q}$, $q = 2^{2k+1}$, the Suzuki group ${}^2B_2(q) = {\operatorname{Sz}}(q)$.
**`"2D"`**
$n\geq 1$, $K ={\bf F}_{q}$, ${}^2D_n(q)$, the orthogonal group $\Omega^-(2n, q)$.
**`"3D"`**
$n = 4$, $K = {\bf F}_{q^3}$, the exceptional group ${}^3D_4(q)$.
**`"2E"`**
$n = 6$, $K = {\bf F}_{q^2}$, the exceptional group ${}^2E_6(q)$.
**`"2F"`**
$n = 4$, $K={\bf F}_{q}$, $q = 2^{2k+1}$, the Ree group ${}^2F_4(q)$, simple except when $q = 2$ when the derived group is simple and is returned by the function `TitsGroup`.
**`"2G"`**
$n = 2$, $K = {\bf F}_{q}$, $q = 3^{2k+1}$, the Ree group ${}^2G_2(q)$, simple except when $q = 3$.
#### The Orders of the Chevalley Groups
##### `ChevalleyOrderPolynomial(type, n: parameters): MonStgElt, RngIntElt -> RngUPolElt`
The orders of the universal Chevalley groups $X_n(q)$ and ${}^tX_n(q)$ are polynomials in $q$. For the twisted groups of types ${}^2A_n$, ${}^3D_4$, and ${}^2E_6$ the parameter $q$ is the order of the fixed field of the Frobenius automorphism.
Other versions of Chevalley groups are quotients of universal Chevalley groups modulo a subgroup of the centre.
##### `FactoredChevalleyGroupOrder(type, n, F: parameters): MonStgElt, RngIntElt, FldFin -> RngIntEltFact`
##### `FactoredChevalleyGroupOrder(type, n, q: parameters): MonStgElt, RngIntElt, RngIntElt -> RngIntEltFact`
```magma
Proof : BoolElt Default: true
Version: MonStgElt Default: "Default"
```
##### `ChevalleyGroupOrder(type, n, F: parameters): MonStgElt, RngIntElt, FldFin -> RngIntEltFact`
##### `ChevalleyGroupOrder(type, n, q: parameters): MonStgElt, RngIntElt, RngIntElt -> RngIntEltFact`
```magma
Version: MonStgElt Default: "Default"
```
The (factored) order of the Chevalley group of a given type and rank over the field $F$ (or ${\bf F}_{q}$). The default is the order of the group returned by `ChevalleyGroup`, which except for types $B_n$, $D_n$, and ${}^2D_n$ is the universal group. The orders of the universal and adjoint Chevalley group can be obtained by setting the parameter `Version` to `Universal` or `Adjoint`. In the factored version the value of `Proof` is passed to the Magma’s factorisation function (q.v.).
#### Classical Groups
Magma offers several functions to construct the classical groups. For most of these functions, it is possible to specify the particular group by giving one of the following combinations of arguments:
**(i)**
The degree $n$ and the coefficient field $K$ of the desired matrix group;
**(ii)**
The degree $n$ of the desired matrix group and a prime power $q$ which relates the group to the appropriate Lie algebra. With the exception of the unitary groups (which will be defined over ${\bf F}_{q^2}$), the resulting group will be defined over ${\bf F}_{q}$; or,
**(iii)**
A full vector space $V = K^n$ on which the desired matrix group should act naturally.
##### Linear Groups
###### `GeneralLinearGroup(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `GeneralLinearGroup(n, K): RngIntElt, FldFin -> GrpMat`
###### `GeneralLinearGroup(V): ModTupRng -> GrpMat`
###### `GL(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `GL(n, K): RngIntElt, FldFin -> GrpMat`
###### `GL(V): ModTupRng -> GrpMat`
Here $n$ is a positive integer, $q$ is the power of a prime, $K$ is a finite field ${\bf F}_{q}$, and $V$ is an $n$-dimensional vector space over $K$. This function constructs the general linear group ${\operatorname{GL}}(n, q)$ (resp. ${\operatorname{GL}}(n, K)$, ${\operatorname{GL}}(V)$) in terms of generating matrices. The intrinsic name may be abbreviated to `GL`.
###### `SpecialLinearGroup(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `SpecialLinearGroup(n, K): RngIntElt, FldFin -> GrpMat`
###### `SpecialLinearGroup(V): ModTupRng -> GrpMat`
###### `SL(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `SL(n, K): RngIntElt, FldFin -> GrpMat`
###### `SL(V): ModTupRng -> GrpMat`
Here $n$ is a positive integer, $q$ is the power of a prime, $K$ is a finite field ${\bf F}_{q}$, and $V$ is an $n$-dimensional vector space over $K$. This function constructs the special linear group ${\operatorname{SL}}(n, q)$ (resp. ${\operatorname{SL}}(n, K)$, ${\operatorname{SL}}(V)$), namely the group of $n\times n$ matrices of determinant 1, in terms of generating matrices. The intrinsic name may be abbreviated to `SL`.
###### `AffineGeneralLinearGroup(GrpMat, n, q): Cat, RngIntElt, RngIntElt -> GrpMat`
###### `AffineGeneralLinearGroup(GrpMat, n, K): Cat, RngIntElt, FldFin -> GrpMat`
###### `AffineGeneralLinearGroup(GrpMat, V): Cat, ModTupRng -> GrpMat`
###### `AffineGeneralLinearGroup(E): GrpPerm -> GrpPerm`
###### `AGL(GrpMat, n, q): Cat, RngIntElt, RngIntElt -> GrpMat`
###### `AGL(GrpMat, n, K): Cat, RngIntElt, FldFin -> GrpMat`
###### `AGL(GrpMat, V): Cat, ModTupRng -> GrpMat`
###### `AGL(E): GrpPerm -> GrpPerm`
Here $n$ is a positive integer greater than or equal to $2$, $q$ is the power of a prime, $K$ is a finite field ${\bf F}_{q}$, and $V$ is an $n$-dimensional vector space over $K$. This function constructs the affine general linear group ${\operatorname{AGL}}(n, q)$ (resp. ${\operatorname{AGL}}(n, K)$, ${\operatorname{AGL}}(V)$) as a subgroup of ${\operatorname{GL}}(n+1, K)$. If the category name `GrpMat` is omitted the affine group will be returned as a permutation group. The intrinsic name may be abbreviated to `AGL`.
If $E$ is a regular elementary abelian permutation group the function constructs the affine general linear group of $E$, regarded as a vector space over the field ${\bf F}_{p}$, where $p$ is the exponent of $E$.
###### `AffineSpecialLinearGroup(GrpMat, n, q): Cat, RngIntElt, RngIntElt -> GrpMat`
###### `AffineSpecialLinearGroup(GrpMat, n, K): Cat, RngIntElt, FldFin -> GrpMat`
###### `AffineSpecialLinearGroup(GrpMat, V): Cat, ModTupRng -> GrpMat`
###### `ASL(GrpMat, n, q): Cat, RngIntElt, RngIntElt -> GrpMat`
###### `ASL(GrpMat, n, K): Cat, RngIntElt, FldFin -> GrpMat`
###### `ASL(GrpMat, V): Cat, ModTupRng -> GrpMat`
Here $n$ is a positive integer greater than or equal to $2$, $q$ is the power of a prime, $K$ is a finite field ${\bf F}_{q}$, and $V$ is an $n$-dimensional vector space over $K$. This function constructs the affine special linear group ${\operatorname{ASL}}(n, q)$ (resp. ${\operatorname{ASL}}(n, K)$, ${\operatorname{ASL}}(V)$) as a subgroup of ${\operatorname{SL}}(n+1, K)$. If the category name `GrpMat` is omitted, the affine group will be returned as a permutation group. The intrinsic name may be abbreviated to `ASL`.
##### Unitary Groups
###### `ConformalUnitaryGroup(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `ConformalUnitaryGroup(n, K): RngIntElt, FldFin -> GrpMat`
###### `ConformalUnitaryGroup(V): ModTupRng -> GrpMat`
###### `CU(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `CU(n, K): RngIntElt, FldFin -> GrpMat`
###### `CU(V): ModTupRng -> GrpMat`
Here $n \geq 2$ is a positive integer, $q$ is the power of a prime, $K$ is the finite field ${\bf F}_{q^2}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the conformal unitary group ${\operatorname{CU}}(n, q)$ (resp. ${\operatorname{CU}}(n, K)$, ${\operatorname{CU}}(V)$) in terms of generating matrices. It preserves the standard hermitian form up to a non-zero scalar multiple. The intrinsic name may be abbreviated to `CU`.
###### `GeneralUnitaryGroup(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `GeneralUnitaryGroup(n, K): RngIntElt, FldFin -> GrpMat`
###### `GeneralUnitaryGroup(V): ModTupRng -> GrpMat`
###### `GU(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `GU(n, K): RngIntElt, FldFin -> GrpMat`
###### `GU(V): ModTupRng -> GrpMat`
Here $n \geq 2$ is a positive integer, $q$ is the power of a prime, $K$ is the finite field ${\bf F}_{q^2}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the general unitary group ${\operatorname{GU}}(n, q)$ (resp. ${\operatorname{GU}}(n, K)$, ${\operatorname{GU}}(V)$) in terms of generating matrices. It preserves the standard hermitian form. The intrinsic name may be abbreviated to `GU`.
###### `SpecialUnitaryGroup(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `SpecialUnitaryGroup(n, K): RngIntElt, FldFin -> GrpMat`
###### `SpecialUnitaryGroup(V): ModTupRng -> GrpMat`
###### `SU(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `SU(n, K): RngIntElt, FldFin -> GrpMat`
###### `SU(V): ModTupRng -> GrpMat`
Here $n$ is an integer greater than or equal to 2, $q$ is the power of a prime, $K$ is the finite field ${\bf F}_{q^2}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the special unitary group ${\operatorname{SU}}(n, q)$ (resp. ${\operatorname{SU}}(n, K)$, ${\operatorname{SU}}(V)$) in terms of generating matrices. The intrinsic name may be abbreviated to `SU`.
###### `ConformalSpecialUnitaryGroup(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `CSU(n, q): RngIntElt, RngIntElt -> GrpMat`
For an integer $n\ge 2$ and a prime power $q$, this function constructs the normaliser of the special unitary group ${\operatorname{SU}}(n,q)$ in ${\operatorname{SL}}(n,q^2)$. The intrinsic name may be abbreviated to `CSU`.
##### Symplectic Groups
###### `ConformalSymplecticGroup(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `ConformalSymplecticGroup(n, K): RngIntElt, FldFin -> GrpMat`
###### `ConformalSymplecticGroup(V): ModTupRng -> GrpMat`
###### `CSp(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `CSp(n, K): RngIntElt, FldFin -> GrpMat`
###### `CSp(V): ModTupRng -> GrpMat`
Here $n$ is an even integer greater than or equal to $4$, $q$ is the power of a prime, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the conformal symplectic group ${\operatorname{CSp}}(n, q)$ (resp. ${\operatorname{CSp}}(n, K)$, ${\operatorname{CSp}}(V)$) in terms of generating matrices. It preserves the standard alternating form up to a non-zero scalar multiple. The intrinsic name may be abbreviated to `CSp`.
###### `SymplecticGroup(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `SymplecticGroup(n, K): RngIntElt, FldFin -> GrpMat`
###### `SymplecticGroup(V): ModTupRng -> GrpMat`
###### `Sp(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `Sp(n, K): RngIntElt, FldFin -> GrpMat`
###### `Sp(V): ModTupRng -> GrpMat`
Here $n$ is an even integer greater than or equal to $4$, $q$ is the power of a prime, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the symplectic group ${\operatorname{Sp}}(n, q)$ (resp. ${\operatorname{Sp}}(n, K)$, ${\operatorname{Sp}}(V)$) in terms of generating matrices. It preserves the standard alternating form. The intrinsic name may be abbreviated to `Sp`.
##### Orthogonal and Spin Groups
###### `ConformalOrthogonalGroup(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `ConformalOrthogonalGroup(n, K): RngIntElt, FldFin -> GrpMat`
###### `ConformalOrthogonalGroup(V): ModTupRng -> GrpMat`
###### `CO(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `CO(n, K): RngIntElt, FldFin -> GrpMat`
###### `CO(V): ModTupRng -> GrpMat`
Here $n$ is an odd integer greater than or equal to $3$, $q$ is the power of a prime, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the conformal orthogonal group ${\operatorname{CO}}(n, q)$ (resp. ${\operatorname{CO}}(n, K)$, ${\operatorname{CO}}(V)$) in terms of generating matrices. It preserves the standard quadratic form up to a non-zero scalar multiple. The intrinsic name may be abbreviated to `CO`.
###### `GeneralOrthogonalGroup(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `GeneralOrthogonalGroup(n, K): RngIntElt, FldFin -> GrpMat`
###### `GeneralOrthogonalGroup(V): ModTupRng -> GrpMat`
###### `GO(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `GO(n, K): RngIntElt, FldFin -> GrpMat`
###### `GO(V): ModTupRng -> GrpMat`
Here $n$ is an odd integer greater than or equal to $3$, $q$ is the power of a prime, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the general orthogonal group ${\operatorname{GO}}(n, q)$ (resp. ${\operatorname{GO}}(n, K)$, ${\operatorname{GO}}(V)$) in terms of generating matrices. It preserves the standard quadratic form. The intrinsic name may be abbreviated to `GO`.
###### `Example: Orthogonal Group in Odd Dimension (ex-681a40)`
We create the $5$-dimensional orthogonal group $G$ over ${\bf F}_{4}$. Note that $G$ is defined by a standard non-degenerate quadratic form $Q$ and it preserves the polar form of $Q$. Since the characteristic is 2 this is a symplectic form. In addition, the dimension is odd and so the symplectic form has a non-trivial radical, which is invariant under the action of $G$. We check that $Q$ is non-degenerate; that is, there are no singular elements in the radical.
```magma
> G := GO(5,4);
> qq := InvariantQuadraticForms(G);
> qq;
[
[ 0 0 0 0 1]
[ 0 0 0 1 0]
[ 0 0 1 0 0]
[ 0 0 0 0 0]
[ 0 0 0 0 0]
]
> Q := qq[1];
> Q eq StandardQuadraticForm(5,4);
true
> V := QuadraticSpace(Q);
> R := Radical(V);
> Dimension(R);
1
> S := SingularRadical(V);
> Dimension(S);
0;
> QuadraticNorm(R.1);
1
> R.1;
( 0 0 1 0 0)
> forall{ g : g in Generators(G) | R.1 * g eq R.1 };
true
```
###### `SpecialOrthogonalGroup(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `SpecialOrthogonalGroup(n, K): RngIntElt, FldFin -> GrpMat`
###### `SpecialOrthogonalGroup(V): ModTupRng -> GrpMat`
###### `SO(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `SO(n, K): RngIntElt, FldFin -> GrpMat`
###### `SO(V): ModTupRng -> GrpMat`
Here $n$ is an odd integer greater than or equal to $3$, $q$ is the power of a prime, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the special orthogonal group ${\operatorname{SO}}(n, q)$ (resp. ${\operatorname{SO}}(n, K)$, ${\operatorname{SO}}(V)$) in terms of generating matrices. The intrinsic name may be abbreviated to `SO`. In characteristic 2 the group coincides with the general orthogonal group.
###### `ConformalSpecialOrthogonalGroup(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `CSO(n, q): RngIntElt, RngIntElt -> GrpMat`
For an odd integer $n\ge 3$ and a prime power $q$, this function constructs the normaliser of the special orthogonal group ${\operatorname{SO}}(n,q)$ in ${\operatorname{SL}}(n,q)$. The intrinsic name may be abbreviated to `CSO`.
###### `ConformalOrthogonalGroupPlus(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `ConformalOrthogonalGroupPlus(n, K): RngIntElt, FldFin -> GrpMat`
###### `ConformalOrthogonalGroupPlus(V): ModTupRng -> GrpMat`
###### `COPlus(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `COPlus(n, K): RngIntElt, FldFin -> GrpMat`
###### `COPlus(V): ModTupRng -> GrpMat`
Here $n$ is an even integer greater than or equal to $2$, $q$ is the power of a prime, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the conformal orthogonal group ${\operatorname{CO}}^+(n, q)$ (resp. ${\operatorname{CO}}^+(n, K)$, ${\operatorname{CO}}^+(V)$) in terms of generating matrices. It preserves the standard quadratic form up to a non-zero scalar multiple. The intrinsic name may be abbreviated to `COPlus`.
###### `GeneralOrthogonalGroupPlus(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `GeneralOrthogonalGroupPlus(n, K): RngIntElt, FldFin -> GrpMat`
###### `GeneralOrthogonalGroupPlus(V): ModTupRng -> GrpMat`
###### `GOPlus(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `GOPlus(n, K): RngIntElt, FldFin -> GrpMat`
###### `GOPlus(V): ModTupRng -> GrpMat`
Here $n$ is an even integer greater than or equal to $2$, $q$ is the power of a prime, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the general orthogonal group ${\operatorname{GO}}^+(n, q)$ (resp. ${\operatorname{GO}}^+(n, K)$, ${\operatorname{GO}}^+(V)$) in terms of generating matrices. It preserves the standard quadratic form. The intrinsic name may be abbreviated to `GOPlus`.
###### `SpecialOrthogonalGroupPlus(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `SpecialOrthogonalGroupPlus(n, K): RngIntElt, FldFin -> GrpMat`
###### `SpecialOrthogonalGroupPlus(V): ModTupRng -> GrpMat`
###### `SOPlus(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `SOPlus(n, K): RngIntElt, FldFin -> GrpMat`
###### `SOPlus(V): ModTupRng -> GrpMat`
Here $n$ is an even integer greater than or equal to $2$, $q$ is the power of a prime, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the special orthogonal group ${\operatorname{SO}}^+(n, q)$ (resp. ${\operatorname{SO}}^+(n, K)$, ${\operatorname{SO}}^+(V)$) in terms of generating matrices. The intrinsic name may be abbreviated to `SOPlus`. In characteristic 2 the group coincides with `GOPlus` and is *not* the kernel of the Dickson invariant.
###### `ConformalSpecialOrthogonalGroupPlus(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `CSOPlus(n, q): RngIntElt, RngIntElt -> GrpMat`
For an odd integer $n\ge 3$ and a prime power $q$, this function constructs the normaliser of the special orthogonal group ${\operatorname{SO}}^+(n,q)$ in ${\operatorname{SL}}(n,q)$. The intrinsic name may be abbreviated to `CSOPlus`.
###### `ConformalOrthogonalGroupMinus(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `ConformalOrthogonalGroupMinus(n, K): RngIntElt, FldFin -> GrpMat`
###### `ConformalOrthogonalGroupMinus(V): ModTupRng -> GrpMat`
###### `COMinus(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `COMinus(n, K): RngIntElt, FldFin -> GrpMat`
###### `COMinus(V): ModTupRng -> GrpMat`
Here $n$ is an even integer greater than or equal to $2$, $q$ is the power of a prime, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the conformal orthogonal group ${\operatorname{CO}}^-(n, q)$ (resp. ${\operatorname{CO}}^-(n, K)$, ${\operatorname{CO}}^-(V)$) in terms of generating matrices. It preserves the standard quadratic form (of Minus type) up to a non-zero scalar multiple. The intrinsic name may be abbreviated to `COMinus`.
###### `GeneralOrthogonalGroupMinus(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `GeneralOrthogonalGroupMinus(n, K): RngIntElt, FldFin -> GrpMat`
###### `GeneralOrthogonalGroupMinus(V): ModTupRng -> GrpMat`
###### `GOMinus(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `GOMinus(n, K): RngIntElt, FldFin -> GrpMat`
###### `GOMinus(V): ModTupRng -> GrpMat`
Here $n$ is an even integer greater than or equal to $2$, $q$ is the power of a prime, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the general orthogonal group ${\operatorname{GO}}^-(n, q)$ (resp. ${\operatorname{GO}}^-(n, K)$, ${\operatorname{GO}}^-(V)$) in terms of generating matrices. It preserves the standard quadratic form (of Minus type). The intrinsic name may be abbreviated to `GOMinus`.
###### `SpecialOrthogonalGroupMinus(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `SpecialOrthogonalGroupMinus(n, K): RngIntElt, FldFin -> GrpMat`
###### `SpecialOrthogonalGroupMinus(V): ModTupRng -> GrpMat`
###### `SOMinus(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `SOMinus(n, K): RngIntElt, FldFin -> GrpMat`
###### `SOMinus(V): ModTupRng -> GrpMat`
Here $n$ is an even integer greater than or equal to $2$, $q$ is the power of a prime, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the special orthogonal group ${\operatorname{SO}}^-(n, q)$ (resp. ${\operatorname{SO}}^-(n, K)$, ${\operatorname{SO}}^-(V)$) in terms of generating matrices. The intrinsic name may be abbreviated to `SOMinus`. In characteristic 2 the group coincides with `GOMinus` and is *not* the kernel of the Dickson invariant.
###### `ConformalSpecialOrthogonalGroupMinus(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `CSOMinus(n, q): RngIntElt, RngIntElt -> GrpMat`
For an odd integer $n\ge 3$ and a prime power $q$, this function constructs the normaliser of the special orthogonal group ${\operatorname{SO}}^-(n,q)$ in ${\operatorname{SL}}(n,q)$. The intrinsic name may be abbreviated to `CSOMinus`.
###### `Omega(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `Omega(n, K): RngIntElt, FldFin -> GrpMat`
###### `Omega(V): ModTupRng -> GrpMat`
Here $n$ is an odd integer greater than or equal to $3$, $q$ is a power of a prime, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the orthogonal group $\Omega(n, K)$ (resp. $\Omega(n, K)$, $\Omega(V)$) in terms of two generating matrices. If $q$ is odd, the group $\Omega(n, K)$ is the kernel of the spinor norm map on ${\operatorname{SO}}(n, K)$); if $q$ is even, it is the kernel of the Dickson invariant.
###### `OmegaPlus(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `OmegaPlus(n, K): RngIntElt, FldFin -> GrpMat`
###### `OmegaPlus(V): ModTupRng -> GrpMat`
Here $n$ is an even integer greater than or equal to $2$, $q$ is a power of a prime, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the orthogonal group $\Omega^+(n, q)$ (resp. $\Omega^+(n, K)$, $\Omega^+(V)$) in terms of two generating matrices. If $q$ is odd, the group $\Omega^+(n, K)$ is the kernel of the spinor norm map on ${\operatorname{SO}}^+(n, K)$. If $q$ is even, it is the kernel of the Dickson invariant.
###### `OmegaMinus(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `OmegaMinus(n, K): RngIntElt, FldFin -> GrpMat`
###### `OmegaMinus(V): ModTupRng -> GrpMat`
Here $n$ is an even integer greater than or equal to $2$, $q$ is a power of a prime, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the orthogonal group $\Omega^-(n, q)$ (resp. $\Omega^-(n, K)$, $\Omega^-(V)$) in terms of two generating matrices. If $q$ is odd, the group $\Omega^-(n, K)$ is the kernel of the spinor norm map on ${\operatorname{SO}}^-(n, K)$. If $q$ is even, it is the kernel of the Dickson invariant.
###### `Spin(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `Spin(n, K): RngIntElt, FldFin -> GrpMat`
###### `Spin(V): ModTupRng -> GrpMat`
Here $n$ is an odd integer greater than or equal to $1$, $q$ is the power of a prime, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the spin group ${\operatorname{Spin}}(n, K)$ (resp. ${\operatorname{Spin}}(n, K)$, ${\operatorname{Spin}}(V)$).
###### `SpinPlus(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `SpinPlus(n, K): RngIntElt, FldFin -> GrpMat`
###### `SpinPlus(V): ModTupRng -> GrpMat`
Here $n$ is an even integer greater than or equal to $2$, $q$ is the power of a prime, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the spin group ${\operatorname{Spin}}^+(n, K)$ (resp. ${\operatorname{Spin}}^+(n, K)$, ${\operatorname{Spin}}^+(V)$).
###### `SpinMinus(n, q): RngIntElt, RngIntElt -> GrpMat`
###### `SpinMinus(n, K): RngIntElt, FldFin -> GrpMat`
###### `SpinMinus(V): ModTupRng -> GrpMat`
Here $n$ is an even integer greater than or equal to $4$, $q$ is the power of a prime, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $n$-dimensional vector space over $K$. This function constructs the spin group ${\operatorname{Spin}}^-(n, K)$ (resp. ${\operatorname{Spin}}^-(n, K)$, ${\operatorname{Spin}}^-(V)$).
#### Exceptional Groups
##### Suzuki Groups
The Suzuki groups are specified slightly differently, as the degree of the group is always four. Thus for this family of groups, the possible combinations of arguments are:
**(i)**
A finite field $K = {\bf F}_{2^{2m+1}}$, over which the resulting matrix group is defined;
**(ii)**
An integer $q = 2^{2m+1}$, corresponding to the field $K = {\bf F}_{q}$ over which the resulting matrix group is defined; or,
**(iii)**
A vector space $V = K^4$ where $K = {\bf F}_{2^{2m+1}}$ on which the resulting matrix group acts naturally. which the resulting
###### `SuzukiGroup(q): RngIntElt -> GrpMat`
###### `SuzukiGroup(K): FldFin -> GrpMat`
###### `SuzukiGroup(V): ModTupRng -> GrpMat`
Here $q$ is a prime power of the form $2^{2n+1}$, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $4$-dimensional vector space over $K$. This function constructs the Suzuki simple group ${\operatorname{Sz}}(q)$ (resp. ${\operatorname{Sz}}(K)$, ${\operatorname{Sz}}(V)$) in terms of two generating matrices. The intrinsic name may be abbreviated to `Sz`.
###### `Example: Symplectic Group of Dimension 10 (ex-df72cd)`
We create the $10$-dimensional symplectic group over ${\bf F}_{8}$:
```magma
> F := FiniteField(8);
> G := SymplecticGroup(10, F);
> G;
MatrixGroup(10, GF(2, 3))
Generators:
[ u 0 0 0 0 0 0 0 0 0]
[ 0 1 0 0 0 0 0 0 0 0]
[ 0 0 1 0 0 0 0 0 0 0]
[ 0 0 0 1 0 0 0 0 0 0]
[ 0 0 0 0 u 0 0 0 0 0]
[ 0 0 0 0 0 u 0 0 0 0]
[ 0 0 0 0 0 0 1 0 0 0]
[ 0 0 0 0 0 0 0 1 0 0]
[ 0 0 0 0 0 0 0 0 1 0]
[ 0 0 0 0 0 0 0 0 0 u^6]
[0 0 0 1 1 1 0 0 0 0]
[1 0 0 0 0 0 0 0 0 0]
[0 1 0 0 0 0 0 0 0 0]
[0 0 1 0 0 0 0 0 0 0]
[0 0 0 1 0 0 0 0 0 0]
[0 0 0 0 1 0 1 0 0 0]
[0 0 0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 0 0 1 0]
[0 0 0 0 0 0 0 0 0 1]
[0 0 0 0 1 0 0 0 0 0]
```
###### `Example: Creating a Suzuki Group (ex-58f4ed)`
We create the Suzuki group over ${\bf F}_{128}$:
```magma
> F := FiniteField(128);
> V := VectorSpace(F, 4);
> S := SuzukiGroup(V);
> S;
MatrixGroup(4, GF(2, 7))
Generators:
[0 0 0 1]
[0 0 1 0]
[0 1 0 0]
[1 0 0 0]
[ w^8 0 0 0]
[ 0 w^120 0 0]
[ 0 0 w^7 0]
[ 0 0 0 w^119]
[ 1 0 0 0]
[ w^8 1 0 0]
[ 0 w 1 0]
[w^17 w^9 w^8 1]
> Order(S);
34093383680
> FactoredOrder(S);
[ <2, 14>, <5, 1>, <29, 1>, <113, 1>, <127, 1> ]
```
##### Small Ree Groups
The Ree groups (${^2}G_2(q)$) are given in an irreducible matrix representation of degree seven. The possible combinations of arguments are:
**(i)**
A finite field $K = {\bf F}_{3^{2m+1}}$ with $m > 0$, over which the matrix group is defined.
**(ii)**
An integer $q = 3^{2m+1}$ with $m > 0$, corresponding to the field $K = {\bf F}_{q}$ over which the group is defined; or,
**(iii)**
A vector space $V = K^7$ where $K = {\bf F}_{3^{2m+1}}$ with $m > 0$, on which the matrix group acts naturally.
###### `ReeGroup(q): RngIntElt -> GrpMat`
###### `ReeGroup(K): FldFin -> GrpMat`
###### `ReeGroup(V): ModTupRng -> GrpMat`
Here $q$ is a prime power of the form $q = 3^{2m+1}$ with $m > 0$, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $7$-dimensional vector space over $K$. This function constructs the Ree group ${^2}G_2(q)$ (resp. ${^2}G_2(K)$, ${^2}G_2(V)$) in terms of standard generating matrices. The intrinsic name may be abbreviated to `Ree`.
##### Large Ree Groups
The Ree groups (${^2}F_4(q)$) are given in an irreducible matrix representation of degree twenty-six. The possible combinations of arguments are:
**(i)**
A finite field $K = {\bf F}_{2^{2m+1}}$ with $m > 0$, over which the matrix group is defined.
**(ii)**
An integer $q = 2^{2m+1}$ with $m > 0$, corresponding to the field $K = {\bf F}_{q}$ over which the group is defined; or,
**(iii)**
A vector space $V = K^{26}$ where $K = {\bf F}_{2^{2m+1}}$ with $m > 0$, on which the matrix group acts naturally.
###### `LargeReeGroup(q): RngIntElt -> GrpMat`
###### `LargeReeGroup(K): FldFin -> GrpMat`
###### `LargeReeGroup(V): ModTupRng -> GrpMat`
Here $q$ is a prime power of the form $q = 2^{2m+1}$ with $m > 0$, $K$ is the finite field ${\bf F}_{q}$, and $V$ is the $26$-dimensional vector space over $K$. This function constructs the Ree group ${^2}F_4(q)$ (resp. ${^2}F_4(K)$, ${^2}F_4(V)$) in terms of standard generating matrices. The intrinsic name may be abbreviated to `LargeRee`.
### Group Recognition
#### Constructive Recognition of Alternating Groups
##### `RecogniseAlternatingOrSymmetric(G : parameters): Grp, RngIntElt -> BoolElt, Map, Map, Map, Map, BoolElt`
```magma
N : RngIntElt Default: 0
Extension : BoolElt Default: false
Epsilon : FldRElt Default: 0.01
Asymptotic: BoolElt Default: false
```
The input group $G$ is isomorphic to $H$, the alternating or symmetric group for some $n \geq 5$. Note that $G$ can be either a matrix or permutation representation of $H$.
The algorithm used is that of [[JLNP13](https://docs.magma-maths.org/references.md#cite-altsymrecogn)]. Since this is Las Vegas, there is a small probability controlled by the optional parameter `Epsilon` that it returns `false` incorrectly.
If the algorithm succeeds, then it returns `true`, an isomorphism from $G$ to $H$, an isomorphism from $H$ to $G$, the map from $G$ to its word group, and the map from the word group to $G$. The sixth value returned is `true` if $H$ is the symmetric group, otherwise false.
The optional parameter `N` is an upper bound for the degree of $H$. If `N` is 0, then the maximal theoretically possible bound for the degree is assumed; this is the degree of $G$ if $G$ is a permutation group, and $\max(9, d + 2)$ or $\max(9, d+1)$ if $G$ is a matrix group of degree $d$, depending on the characteristic of the field. If the optional parameter `Extension` is `true`, then $G$ is isomorphic to a central extension of $H$ for some $n \geq 5$. Now the first two maps returned are an epimorphism from $G$ onto $H$ with kernel $Z(G)$ and a map from $H$ to $G$ that induces an isomorphism from $H$ onto $G/Z(G)$.
If the optional parameter `Asymptotic` is `true`, then the map from $H$ to $G$ implements the asymptotically efficient algorithm of Beals et al. [[BLGN+03b](https://docs.magma-maths.org/references.md#cite-altsymrecog1)]. Otherwise, the algorithm employed for this map is that of [[BP00](https://docs.magma-maths.org/references.md#cite-bratus-pak)], which is usually faster for moderate degrees.
If the algorithm is not successful, then `false` is returned.
The algorithm consists of two parts. The first part finds the degree of the alternating group and constructs standard generators, cf. [[JLNP13](https://docs.magma-maths.org/references.md#cite-altsymrecogn)]. The second part verifies that these elements generate $G$, and constructs isomorphisms between $G$ and $H$, cf. [[BLGN+03b](https://docs.magma-maths.org/references.md#cite-altsymrecog1)]. The implementation of the first part was developed by Sebastian Jambor. The implementation of the second part was developed by Jonathan Conder; he also extended the algorithm to work for both $n \in \{5,\ldots,10\}$ and central extensions.
##### `AlternatingOrSymmetricElementToWord(G, g): Grp, GrpElt -> BoolElt, GrpSLPElt`
If $g \in G$ and $G$ has been recognised by `RecogniseAlternatingOrSymmetric`, this function returns `true` and an element of the word group for $G$ which evaluates to $g$. Otherwise, it returns `false`. This facilitates membership testing in $G$.
The implementation was developed by Jonathan Conder.
##### `Example: Recognising a Representation of A13 (ex-98afe7)`
We illustrate the use of these functions for a representation of $A_{13}$.
```magma
> A:= AlternatingGroup (13);
> H:= Stabiliser(A, {1,2});
> G := CosetImage (A, H);
> Degree (G);
78
> success, bb_to_perm, perm_to_bb, bb_to_wg, wg_to_bb, is_sym :=
> RecogniseAlternatingOrSymmetric (G);
>
> success;
true
> is_sym;
false
>
> x:= Sym(78)!(1, 35, 16, 28, 14, 26, 69, 5, 74)(2, 54,
> 67, 18, 51, 63, 6, 50, 77)(3, 33, 78, 12, 34, 29, 19, 15, 73)
> (4, 52, 61, 24, 49, 60, 68, 38, 64)(7, 20, 71, 17,
> 32, 11, 72, 8, 36)(9, 76, 47, 31, 56, 62, 13, 53, 59)
> (10, 70, 57, 23, 37, 22, 21, 27, 25)(30, 45, 46, 43, 42,
> 44, 40, 41, 75)(39, 55, 65)(48, 66, 58);
>
> flag, w := AlternatingOrSymmetricElementToWord (G, x);
> "Is x in G?", flag;
Is x in G? true
> Evaluate (w, [G.i: i in [1..Ngens (G)]]) eq x;
true
>
> perm_image:= bb_to_perm(x);
> perm_image;
(1, 4, 9)(2, 6, 3, 5, 10, 7, 8, 11, 12)
>
> y := Random (G);
> w := bb_to_wg (y);
> Evaluate (w, [G.i: i in [1..Ngens (G)]]) eq y;
true
```
##### `RecogniseSymmetric(G, n: parameters): Grp, RngIntElt -> BoolElt, Map, Map, Map, Map, BoolElt`
```magma
maxtries : RngIntElt Default: 100n + 5000
Extension: BoolElt Default: false
```
The group $G$ should be known to be isomorphic to the symmetric group $S_n$ for some $n \ge 8$. The Bratus-Pak algorithm [[BP00](https://docs.magma-maths.org/references.md#cite-bratus-pak)] (implemented by Derek Holt) is used to define an isomorphism between $G$ and $S_n$. If successful, return `true`, homomorphism from $G$ to $S_n$, homomorphism from $S_n$ to $G$, the map from $G$ to its word group and the map from the word group to $G$.
If the optional parameter `Extension` is set, then the group $G$ should be known to be isomorphic either to $S_n$ or to a perfect central extension $2.S_n$. In that case, the first two maps returned will be a homomorphism from $G$ to $S_n$ and a map from $S_n$ to $G$ that induces a homomorphism onto $G/Z(G)$. The sixth value returned will be `true`, if $G \cong 2.S_n$ and `false`, if $G \cong 2.A_n$.
If unsuccessful, `false` is returned. This will always occur if the input group is not isomorphic to $S_n$ (or $2.S_n$ when `Extension` is set) with $n \ge 8$, and may occur occasionally even when $G$ is isomorphic to $S_n$. The optional parameter `maxtries` (default $100n + 5000$) can be used to control the number of random elements chosen before giving up.
##### `SymmetricElementToWord(G, g): Grp, GrpElt -> BoolElt, GrpSLPElt`
If $g$ is an element of $G$ which has been constructively recognised to be isomorphic to $S_n$ (or $2.S_n$), then return `true` and element of word group for $G$ which evaluates to $g$. Otherwise return `false`. This facilitates membership testing in $G$.
##### `RecogniseAlternating(G, n: parameters): Grp, RngIntElt -> BoolElt, Map, Map, Map, Map, BoolElt`
```magma
maxtries : RngIntElt Default: 100n + 5000
Extension: BoolElt Default: false
```
The group $G$ should be known to be isomorphic to the alternating group $A_n$ for some $n \ge 9$. The Bratus-Pak algorithm [[BP00](https://docs.magma-maths.org/references.md#cite-bratus-pak)] (implemented by Derek Holt) is used to define an isomorphism between $G$ and $A_n$. If successful, return `true`, homomorphism from $G$ to $A_n$, homomorphism from $A_n$ to $G$, the map from $G$ to its word group and the map from the word group to $G$.
If the optional parameter `Extension` is set, then the group $G$ should be known to be isomorphic either to $A_n$ or to a perfect central extension $2.A_n$. In that case, the first two maps returned will be a homomorphism from $G$ to $A_n$ and a map from $A_n$ to $G$ that induces a homomorphism onto $G/Z(G)$. The sixth value returned will be `true`, if $G \cong 2.A_n$ and `false` otherwise.
If unsuccessful, `false` is returned. This will always occur if the input group is not isomorphic to $A_n$ (or $2.A_n$ when `Extension` is set) with $n \ge 9$, and may occur occasionally even when $G$ is isomorphic to $A_n$. The optional parameter `maxtries` (default $100n + 5000$) can be used to control the number of random elements chosen before giving up.
##### `AlternatingElementToWord(G, g): Grp, GrpElt -> BoolElt, GrpSLPElt`
If $g$ is an element of $G$ which has been constructively recognised to be isomorphic to $A_n$ (or $2.A_n$), then return `true` and element of word group for $G$ which evaluates to $g$. Otherwise return `false`. This facilitates membership testing in $G$.
##### `GuessAltsymDegree(G: parameters): Grp -> BoolElt, MonStgElt, RngIntElt`
```magma
maxtries : RngIntElt Default: 5000
Extension: BoolElt Default: false
```
The group $G$ should be believed to be isomorphic to $S_n$ or $A_n$ for some $n > 6$, or to $2.S_n$ or $2.A_n$ if the optional parameter `Extension` is set. This function attempts to determine $n$ and whether $G$ is symmetric or alternating. It does this by sampling orders of elements. It returns either `false`, if it is unable to make a decision after sampling `maxtries` elements (default $5000$), or `true`, *type*, and $n$, where *type* is “Symmetric” or “Alternating”, and $n$ is the degree. If $G$ is not isomorphic to $S_n$ or $A_n$ (or $2.S_n$ or $2.A_n$ when `Extension` is set) for $n > 6$, then the output is meaningless - there is no guarantee that `false` will be returned. There is also a small probability of a wrong result or `false` being returned even when $G$ is $S_n$ or $A_n$ with $n > 6$. This function was written by Derek Holt.
##### `Example: Guessing the Degree of an Alternating Group (ex-785664)`
For a group $G$ which is believed to be isomorphic to $S_n$ or $A_n$ for some unknown value of $n > 6$, the function `GuessAltsymDegree` can be used to try to guess $n$, and then `RecogniseSymmetric` or `RecogniseAlternating` can be used to confirm the guess.
```magma
> G:= sub< GL(10,5) |
> PermutationMatrix(GF(5),Sym(10)![2,3,4,5,6,7,8,9,1,10]),
> PermutationMatrix(GF(5),Sym(10)![1,3,4,5,6,7,8,9,10,2]) >;
> GuessAltsymDegree(G);
true Alternating 10
> flag, m1, m2, m3, m4 := RecogniseAlternating(G,10);
> flag;
true
> x:=Random(G); Order(x);
8
> m1(x);
(1, 2, 4, 9, 10, 8, 6, 3)(5, 7)
> m2(m1(x)) eq x;
true
> m4(m3(x)) eq x;
true
> flag, w := AlternatingElementToWord(G,x);
> flag;
true
> m4(w) eq x;
true
> y := Random(Generic(G));
> flag, w := AlternatingElementToWord(G,y);
> flag;
false
> flag, m1, m2, m3, m4 := RecogniseAlternating(G,11);
> flag;
false
> flag, m1, m2, m3, m4 := RecogniseSymmetric(G,10);
> flag;
false
```
The nature of the `GuessAltsymDegree` function is that it assumes that its input is either an alternating or symmetric group and then tries to guess which one and the degree. As such, it is almost always correct when the input is an alternating or symmetric group, but will often return a bad guess when the input group is not of this form, as in the following example.
```magma
> GuessAltsymDegree(Sym(50));
true Symmetric 50
> GuessAltsymDegree(Alt(73));
true Alternating 73
> GuessAltsymDegree(PSL(5,5));
true Alternating 82
```
#### Determining the Type of a Finite Group of Lie Type
Given a finite quasisimple group of Lie type in any representation, the functions in this section apply probabilistic algorithms to determine its defining characteristic and type as a Lie group.
##### `LieCharacteristic(G : parameters): Grp -> RngIntElt`
```magma
NumberRandom: RngIntElt Default: 100
Verify : BoolElt Default: true
```
Given a finite quasisimple permutation or matrix group $G$ which is of Lie type, determine its defining characteristic. The Monte Carlo algorithm implemented by this function is that of Liebeck and O’Brien [[LO07](https://docs.magma-maths.org/references.md#cite-liebeck-obrien)]. Since it is Monte Carlo, there is a small probability of error. The number of random elements considered is `NumberRandom`. If `Verify` is `true`, then we first verify that $G$ is perfect by applying `IsProbablyPerfect`.
##### `Example: Characteristic of a Group of Lie Type (ex-337eef)`
```magma
> F := GF (4);
> w := PrimitiveElement (F);
> a := [
> 0,w^3,0,0,0,
> w^3,0,0,0,0,
> 0,0,0,w^3,0,
> 0,0,w^3,0,0,
> w^2,w^2,w^3,w^3,w^3];
> b := [
> 0,0,w^3,0,0,
> w^1,w^2,w^2,0,0,
> w^2,w^1,w^2,0,0,
> 0,0,0,0,w^3,
> w^2,w^2,w^2,w^3,w^3];
> G := sub ;
> LieCharacteristic(G);
11
```
##### `LieType(G, p : parameters): GrpMat, RngIntElt -> BoolElt, Tup`
##### `LieType(G, p : parameters): GrpMat, RngIntElt -> BoolElt, Tup`
```magma
NumberRandom: RngIntElt Default: 100
```
If the matrix or permutation group $G$ is nearly simple, and its non-abelian composition factor is isomorphic to a group of Lie type in characteristic $p$, then this function returns `true` and its standard Chevalley name. Otherwise it returns `false`.
The algorithm is that of Babai, Kantor, Pálfy, and Seress [[BKPS02](https://docs.magma-maths.org/references.md#cite-bkps)]; this implementation was developed by Malle and O’Brien. Since it is Monte Carlo, there is a small probability of error. The number of random elements considered is `NumberRandom`.
The standard name is a tuple that defines the isomorphism type of the composition factor. It is similar to that employed by `CompositionFactors`, described in the Permutation Groups chapter.
If the composition factor is a group of Lie type, then the tuple is $$ and it defines the adjoint Chevalley group of Lie series $s$ and Lie rank $n$ over $GF (q)$. The tuple entries are valid arguments for `ChevalleyGroup`.
If the composition factor is an alternating group, and so lies in family 17, then the tuple is $<17, n, 0>$ and it defines the alternating group of degree $n$.
If the composition factor is a sporadic group and so lies in family 18, then the tuple is $<18, n, s>$; the string $s$ is its standard Atlas name and $n$ is the number of the group in family 18.
##### `SimpleGroupName(G : parameters): GrpMat -> BoolElt, List`
##### `SimpleGroupName(G : parameters): GrpPerm -> BoolElt, List`
```magma
NumberRandom: RngIntElt Default: 100
```
If the matrix or permutation group $G$ is nearly simple, this function returns `true` and a list of possible names for its non-abelian simple composition factor; otherwise it returns `false`. Since it is Monte Carlo, there is a small probability of error. The number of random elements considered is `NumberRandom`. The list of standard names follows the convention described above.
The algorithm and implementation were developed by Malle and O’Brien; it uses `LieType` and `LieCharacteristic`.
##### `Example: Naming a Simple Group (ex-ffaa04)`
We create the classical group $\Omega(7, 5)$ in its natural representation and apply `SimpleGroupName` to it.
```magma
> SetSeed(1);
> G := Omega(7, 5);
> flag, name := SimpleGroupName(G);
> name;
[* *]
```
We create a certain $5$-dimensional matrix group over $GF(3)$ and determine which simple group it is.
```magma
> F := GF(3);
> P := GL(5,F);
> gens := [
> P![2,1,2,1,2,2,0,0,0,2,0,2,0,0,0,0,1,2,0,1,1,0,2,2,1],
> P![2,1,0,2,1,1,2,0,2,2,1,1,2,1,1,0,2,0,1,1,1,1,2,2,2]];
> G := sub ;
> flag, name := SimpleGroupName(G);
> flag;
true
> name;
[* <18, 1, M11> *]
> /* naming an alternating group */
> G := MatrixGroup<4, GF(2) |
> [ 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0 ],
> [ 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0 ] >;
> flag, name := SimpleGroupName(G);
> flag;
true
> /* this is A5 */
> name;
[* <17, 5, 0> *]
> /* naming a classical group */
> F := GF(7^2);
> P := GL (6,F);
> w := PrimitiveElement (F);
> gens := [
> P![w^12,w^36, 0, 5, 2, 0,w^44,w^36, 0, 6, 2, 0,
> w^42,w^42,w^28,w^22,w^22, 3, 4, 3, 0,w^36,w^12, 0,
> 2, 3, 0,w^20,w^12, 0,w^14,w^14, 1,w^18,w^18, w^4],
>
> P![w^38,w^26,w^25,w^21, w^9, 3,w^21,w^45,w^33, w^4,w^28,
> 2, 6, 4, w^1, w^7,w^15, 4, 1,w^36,w^35, w^5,w^41, 5,
> w^31, w^7,w^43,w^36,w^12, 1,w^34,w^42,w^11,w^39,w^47, 2]
> ];
> G := sub
;
> flag, name := LieType(G, 5);
> flag;
true
> name;
> /* so this is SL(2, 5) */
```
#### Classical Forms
Let $G$ be an absolutely irreducible subgroup of $\GL(d,q)$. The following functions compute symplectic, unitary, and orthogonal forms of the underlying vector space $V$ left invariant by the action of $G$.
A *bilinear* form is a bilinear function $\kappa$ from $V\times V \rightarrow F$. It is $G$-invariant modulo scalars if for each $g \in G$ there is a $\mu_g \in F$ such that $\kappa(vg,wg) = \mu_g \kappa(v,w)$ for all $v, w \in V$.
Now suppose that $a\mapsto \bar{a}$ is an automorphism of $F$ of order 2. A *sesquilinear* form is a biadditive function $\kappa$ from $V\times V \rightarrow F$ such that $\kappa( au, bv) = a\bar{b} \kappa(u,v)$ for all $u,v \in V$ and $a,b\in F$. It is $G$-invariant modulo scalars if for each $g \in G$ there is a $\mu_g \in F$ such that $\kappa(vg,wg) = \mu_g \kappa(v,w)$ for all $v, w \in V$.
A quadratic form is a function $\chi : V \rightarrow F$ such that
**(1)**
$\chi(av) = a^2 \chi(v)$ for all $a\in F$, $v\in V$; and
**(2)**
the form $\kappa$, defined by $\kappa(u,v) = \chi( u + v ) - \chi(u) - \chi(v)$ for all $u,v \in V$, is bilinear.
It is $G$-invariant if for each $g \in G$, $\chi(vg) = \chi(v)$ for all $v \in V$. It is $G$-invariant modulo scalars if for each $g \in G$ there is a $\mu_g \in F$ such that $\chi(vg) = \mu_g \chi(v)$ for all $v \in V$.
A bilinear form which is $G$-invariant (modulo scalars) is represented by a matrix $B$ such that $g * B*{g}^{tr} = \mu_g B$ for all $g\in G$ and is unique up to multiplication by an element of $F$. Assume $F$ has an automorphism $a \mapsto \bar{a}$ of order $2;$ a sesquilinear form is a matrix $B$ such that $g * B*\bar{g}^{tr} = \mu_g B$ for all $g\in G$ and is unique up to multiplication by an element of $F$ (where $\bar{g}$ denotes the matrix obtained from $g$ by replacing each entry $g_{ij}$ by $\bar{g_{ij}}$). A quadratic form is represented by an upper triangular matrix $Q$ such that the matrix $g * Q * g^{tr}$, normalized into an upper triangular matrix, equals $\mu_g Q$.
The functions below will exit with an error message if the input group $G$ is reducible. They may also exit with error if $G$ is not absolutely irreducible, or if `Scalars` is `true` and the derived subgroup $[G,G]$ of $G$ is not absolutely irreducible. They may however sometimes succeed in finding a fixed form when $G$ is irreducible but not absolutely irreducible.
##### `ClassicalForms(G: parameters): GrpMat -> Rec`
```magma
Scalars: BoolElt Default: false
```
Given as input a matrix group $G$ acting absolutely irreducibly on the underlying vector space $V$ over the field $F$, `ClassicalForms` will try to find a classical form which is $G$-invariant or prove that no such form exists. If the optional argument `Scalars` is `true` then it will look for a form which is $G$-invariant modulo scalars. When `Scalars` is `true`, it is only guaranteed to succeed when $[G,G]$ acts absolutely irreducibly on $V$. If it finds a fixed form, then it will stop and will not look for alternative fixed forms of different types.
The classical forms are: *symplectic* (non-degenerate, alternating bilinear), *unitary* (non-degenerate sesquilinear) or *orthogonal* (a *symmetric bilinear form* and a *quadratic* form).
The function `ClassicalForms` returns a record `forms` which contains the components `formType`, `sign`, `bilinearForm`, `sesquilinearForm`, `quadraticForm`, and `scalars`. Depending on the entry `formType` the record components are set to indicate:
**`"unknown"`**
it is not known whether $G$ fixes a classical form.
**`"linear"`**
it is known that $G$ does not fix a classical form modulo scalars.
**`"symplectic"`**
$G$ fixes a symplectic form modulo scalars. The matrix of the form is stored in `bilinearForm` and the scalars for each generator of $G$ are stored in `scalars`. In characteristic two this also implies that no quadratic form is fixed.
**`"unitary"`**
$G$ fixes a unitary form (modulo scalars). The matrix of the form is stored in `sesquilinearForm`. The scalars for each generator of $G$ are stored in `scalars`.
**`"orthogonalcircle"`, `"orthogonalplus"`, `"orthogonalminus"`**
$G$ fixes an orthogonal form modulo scalars. The matrix of the bilinear form is stored in `bilinearForm` and the corresponding quadratic form in `quadraticForm`. The scalars for each generator of $G$ are stored in `scalars`. In the orthogonal case, `sign` is set to 0, 1, or -1 when `formType` is `"orthogonalcircle"`, `"orthogonalplus"`, or `"orthogonalminus"`, respectively.
##### `SymplecticForm(G: parameters): GrpMat -> BoolElt, AlgMatElt [,SeqEnum]`
```magma
Scalars: BoolElt Default: false
```
If the absolutely irreducible group $G$ preserves a symplectic form (modulo scalars if the optional argument `Scalars` is `true`), this function returns `true` and the matrix of the form. If it is known that $G$ does not preserve such a form it returns `false`. If it cannot decide (perhaps because the group does not act absolutely irreducibly), then it exits with an error message. If `Scalars` is `true`, then the list of scalars for the generators of $G$ is also returned.
##### `SymmetricBilinearForm(G: parameters): GrpMat -> BoolElt, AlgMatElt, MonStgElt [,SeqEnum]`
```magma
Scalars: BoolElt Default: false
```
If the absolutely irreducible group $G$ preserves an orthogonal form (modulo scalars if the optional argument `Scalars` is `true`), then this function returns `true`, the matrix of the symmetric bilinear form, and the type of the form (as in [`ClassicalForms`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-grpmat-classicalforms)). If it is known that $G$ does not preserve such a form, it returns `false`. If it cannot decide, then it exits with an error message. If `Scalars` is `true`, then the list of scalars for the generators of $G$ is also returned.
##### `QuadraticForm(G): GrpMat -> BoolElt, AlgMatElt, MonStgElt [,SeqEnum]`
```magma
Scalars: BoolElt Default: false
```
If the absolutely irreducible group $G$ preserves a quadratic form (modulo scalars if the optional argument `Scalars` is `true`), this function returns `true`, the matrix of the form in upper triangular form, and the type of the form (as in [`ClassicalForms`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-grpmat-classicalforms)). If it is known that $G$ does not preserve such a form it returns `false`. If it cannot decide, then it exits with an error message. If `Scalars` is `true`, then the list of scalars for the generators of $G$ is also returned.
##### `UnitaryForm(G): GrpMat -> BoolElt, AlgMatElt [,SeqEnum]`
```magma
Scalars: BoolElt Default: false
```
If the absolutely irreducible group $G$ preserves a unitary form (non-degenerate sesquilinear) (modulo scalars if the optional argument `Scalars` is `true`), then this function returns `true` and the matrix of the form. If it is known that $G$ does not preserve such a form, it returns false. If it cannot decide, then it exits with an error message. If `Scalars` is `true`, then the list of scalars for the generators of $G$ is also returned.
##### `FormType(G): GrpMat -> MonStgElt`
```magma
Scalars: BoolElt Default: false
```
If the absolutely irreducible group $G$ preserves a classical form (modulo scalars if the optional argument `Scalars` is `true`), this function returns its type (see [`ClassicalForms`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-grpmat-classicalforms)). Otherwise it returns `"unknown"`.
##### `Example: Classical Forms of an Orthogonal Group (ex-9382cf)`
```magma
> G := Omega( 9, 11 );
> ClassicalForms( G );
rec | bilinearForm :=
[ 0 0 0 0 0 0 0 0 1]
[ 0 0 0 0 0 0 0 1 0]
[ 0 0 0 0 0 0 1 0 0]
[ 0 0 0 0 0 1 0 0 0]
[ 0 0 0 0 6 0 0 0 0]
[ 0 0 0 1 0 0 0 0 0]
[ 0 0 1 0 0 0 0 0 0]
[ 0 1 0 0 0 0 0 0 0]
[ 1 0 0 0 0 0 0 0 0],
quadraticForm :=
[ 0 0 0 0 0 0 0 0 1]
[ 0 0 0 0 0 0 0 1 0]
[ 0 0 0 0 0 0 1 0 0]
[ 0 0 0 0 0 1 0 0 0]
[ 0 0 0 0 3 0 0 0 0]
[ 0 0 0 0 0 0 0 0 0]
[ 0 0 0 0 0 0 0 0 0]
[ 0 0 0 0 0 0 0 0 0]
[ 0 0 0 0 0 0 0 0 0],
sesquilinearForm := false, bilinFlag := true, sesquiFlag := false,
scalars := [ 1, 1 ], formType := orthogonalcircle, sign := 0>
> FormType( G );
orthogonalcircle
> SymplecticForm( G );
false
```
##### `TransformForm(form, type): AlgMatElt, MonStgElt -> GrpMatElt`
Return a matrix $m$ such that $G^m$ lies in the classical group returned by the Magma function `GU`, `Sp`, or `GO(Plus/Minus)`. The argument `form` should be a classical form of type `type` fixed by an absolutely irreducible subgroup $G$ of $GL(d,q)$. It should be the bilinear or sesquilinear form fixed by $G$, except when $G$ is orthogonal in characteristic 2, in which case it should be the quadratic form. The argument `type` should be as in the `formType` component of the record returned by [`ClassicalForms`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-grpmat-classicalforms); i.e. one of `"symplectic"`, `"unitary"`, `"orthogonalcircle"`, `"orthogonalplus"`, or `"orthogonalminus"`.
The code for this function for all cases other than orthogonal in characteristic $2$ was written by Giovanni de Franceschi and James Wilson.
##### `TransformForm(G): GrpMat -> GrpMatElt`
```magma
Scalars: BoolElt Default: false
```
This function calls [`ClassicalForms`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-grpmat-classicalforms) to find a form fixed by the absolutely irreducible subgroup $G$ of $GL(d,q)$. If `Scalars` is `true`, then [`ClassicalForms`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-grpmat-classicalforms) is called with `Scalars` set to `true`, so that a form fixed module scalars is found. If a form `form` of type `type` is fixed, then it returns `TransformForm(form, type)`. Otherwise it returns `false`.
##### `SpinorNorm(g, form): GrpMatElt, AlgMatElt -> RngIntElt`
The group element $g$ should be an element of the finite orthogonal group that preserves the given symmetric bilinear form with matrix `form`. If the characteristic is odd, this function returns the spinor norm of $g$. If the characteristic is even it returns the Dickson invariant of $g$; namely the rank modulo 2 of $g - I$. Thus for an element $g$ of the special orthogonal group the return value is 0 if $g$ belongs to the `Omega(Plus/Minus)` subgroup of index 2; otherwise the return value is 1. However, as illustrated in the following example, the spinor norm alone cannot be used to check whether an element of the orthogonal group is in $\Omega$.
##### `Example: Spinor Norm in an Orthogonal Group (ex-b5d734)`
This function can be used to check whether an element of the orthogonal group, say ${\operatorname{GO}}^+(d,q)$, belongs to $\Omega^+(d,q)$. First check that the element belongs to ${\operatorname{SO}}^+(d,q)$.
```magma
> isInOmega := func< g,form |
> Determinant(g) eq 1 and SpinorNorm(g,form) eq 0 >;
> G := GOPlus(6,3);
> g := G![
> [ 1, 0, 0, 0, 0, 0],
> [ 0, 0, 0, 0, 2, 0],
> [ 0, 0, 1, 0, 0, 0],
> [ 0, 0, 0, 1, 0, 0],
> [ 0, 2, 0, 0, 0, 0],
> [ 0, 0, 0, 0, 0, 1] ];
> _, form := SymmetricBilinearForm(G);
> SpinorNorm(g,form);
0
> isInOmega(g,form);
false
```
#### Recognizing Classical Groups in their Natural Representation
Let $G$ be an irreducible subgroup of ${\operatorname{GL}}(d,q)$. The following algorithm is designed to test whether $G$ contains the corresponding classical group $\Omega$ and is contained in $\Delta$. Here $\Omega$ and $\Delta$ are defined as follows:
**•**
Case “linear”: $\Delta = {\operatorname{GL}}(d,q),$ $\Omega = {\operatorname{SL}}( d, q)$
**•**
Case “symplectic”: $\Delta = {\operatorname{CSp}}(d,q),$ $\Omega = {\operatorname{Sp}}( d, q)$
**•**
Case “orthogonalplus”: $\Delta = {\operatorname{CO}}^+(d,q),$ $\Omega = \Omega^+(d,q)$
**•**
Case “orthogonalminus”: $\Delta = {\operatorname{CO}}^-(d,q),$ $\Omega = \Omega^-(d,q)$
**•**
Case “orthogonalcircle”:$\Delta = {\operatorname{CO}}^\circ(d,q),$ $\Omega = \Omega^\circ(d,q)$
**•**
Case “unitary”: $\Delta = {\operatorname{CU}}(d,q),$ $\Omega = {\operatorname{SU}}(d,q)$
##### `RecognizeClassical(G : parameters): GrpMat -> BoolElt`
##### `RecogniseClassical(G : parameters): GrpMat -> BoolElt`
```magma
Case : MonStgElt Default: "unknown"
NumberOfElements: RngIntElt Default: 25
Classical : Verbose Default: 3
```
`RecognizeClassical` takes as input a group $G$, which is a subgroup of $\GL(d,q)$. The parameter `Case` is one of `"linear"`, `"symplectic"`, `"orthogonalplus"`, `"orthogonalminus"`, `"orthogonalcircle"`, `"unitary"`, or `"unknown"`; if `Case` is supplied, then the algorithm seeks to decide for this case only. The parameter `NumberOfElements` is the number of random elements selected from $G$ during the execution of the algorithm.
The output of `RecognizeClassical` is either `true`, `false`, or `"Does not apply"`. If the algorithm returns `true`, then we know with certainty that $G$ contains $\Omega$ and is contained in $\Delta$. Note that the proof of correctness of the algorithm depends on the finite simple group classification. If it returns `false` then either $G$ does not contain $\Omega$, or $G$ is not contained in $\Delta$, or $G$ is not irreducible, or there is a small chance that $G$ is contained in $\Delta$ and contains $\Omega$. More precisely, if the irreducible group $G$ is contained in $\Delta$ and really does contain $\Omega$ then the probability with which the algorithm returns `false` is less than $\eps$, where $\eps$ is a real number between 0 and 1. The smaller the value of $\eps$, the larger `NumberOfElements` must be. If the algorithm returns `"Does not apply"` then it is not applicable to the given group.
If `"Classical"` is set to verbose then, where `RecognizeClassical` returns `true`, it also prints the statement “Proved that the group contains a classical group of type *case* in $n$ random selections”, where $n$ is the number of selections needed. If it returns `false`, it prints a statement giving some indication of why the algorithm reached this conclusion.
Theoretical details of the algorithms used may be found in Niemeyer & Praeger [[NP97](https://docs.magma-maths.org/references.md#cite-niemeyer-praeger-97)][[NP98](https://docs.magma-maths.org/references.md#cite-niemeyer-praeger-98)][[NP99](https://docs.magma-maths.org/references.md#cite-niemeyer-praeger-99)] and Praeger [[Pra99](https://docs.magma-maths.org/references.md#cite-praeger-prim)]. Its approach is based on the ${\operatorname{SL}}$-recognition algorithm (Neumann & Praeger, [[NP92](https://docs.magma-maths.org/references.md#cite-neumann-praeger-92)]).This implementation also uses algorithms described in Celler & Leedham-Green [[CLG97b](https://docs.magma-maths.org/references.md#cite-clg-order)][[CLG97a](https://docs.magma-maths.org/references.md#cite-clg-recog)] and Celler et al. [[CLGM+95](https://docs.magma-maths.org/references.md#cite-randomelements)].
For small fields $(q < 2^{16}),$ the cost of this implementation for a given value of `NumberOfElements` is $O( d^3 \log d )$ bit operations.
##### `IsLinearGroup(G): GrpMat -> BoolElt`
This function tests whether the subgroup $G$ of ${\operatorname{GL}}(d,q)$ contains ${\operatorname{SL}}(d,q)$. If the function can establish this fact, it returns `true` and otherwise `false`. Hence, if `IsLinearGroup` returns `false`, there is a small chance that $G$ nevertheless contains ${\operatorname{SL}}(d,q)$. See `RecognizeClassical` for more details.
##### `IsSymplecticGroup(G): GrpMat -> BoolElt`
This function tests whether the subgroup $G$ of ${\operatorname{CSp}}(d,q)$ contains ${\operatorname{Sp}}(d,q)$. If the function can establish this fact, it returns `true` and otherwise `false`. Hence, if `IsSymplecticGroup` returns `false`, there is a small chance that $G$ nevertheless contains ${\operatorname{Sp}}(d,q)$. See `RecognizeClassical` for more details.
##### `IsOrthogonalGroup(G): GrpMat -> BoolElt`
This function tests whether the subgroup $G$ of ${\operatorname{CO}}^\epsilon(d,q)$ contains $\Omega^\epsilon(d,q)$. If the function can establish this fact, it returns `true` and otherwise `false`. Hence, if `IsOrthogonalGroup` returns `false`, there is a small chance that $G$ nevertheless contains $\Omega^\epsilon(d,q)$. See `RecognizeClassical` for more details.
##### `IsUnitaryGroup(G): GrpMat -> BoolElt`
This function tests whether the subgroup $G$ of ${\operatorname{CU}}(d,q)$ contains ${\operatorname{SU}}(d,q)$. If the function can establish this fact, it returns `true` and otherwise `false`.
##### `ClassicalType(G): GrpMat -> MonStgElt`
If $G$ is known to be a classical subgroup of ${\operatorname{GL}}(d,q)$ this function returns the appropriate classical type as a string. i.e., One of `"linear"`, `"symplectic"`, `"orthogonalplus"`, `"orthogonalminus"`, `"orthogonalcircle"`, or `"unitary"`. Otherwise the function returns `false`.
##### `ClassicalGroupType(G): GrpMat -> BoolElt, MonStgElt`
This is a refinement of `ClassicalType` developed by O’Brien and Taylor. If $G$ can be identified as a natural classical group in its natural representation, return `true` and the type of the group – one of the strings listed under ‘subtype’; otherwise return `false`.
```
type subtype
---------------------------------------------------
linear GL, SL
symplectic CSp, Sp, ExtSp
orthogonalplus CGO+, GO+, SO+, Omega+, ExtOmega+
orthogonalminus CGO-, GO-, SO-, Omega-, ExtOmega-
orthogonalcircle CGO, GO, SO, Omega, ExtOmega
unitary CGU, GU, SU, ExtSU, AltSU
---------------------------------------------------
```
A group of type `"ExtSp"` is properly contained between the symplectic group and the conformal symplectic group. A group of type `"ExtSU"` is properly contained between the special unitary group and the general unitary group whereas a group of type `"AltSU"` is a subgroup of the conformal unitary group which contains the special unitary group but is not contained in the general unitary group. A group of type `"ExtOmega"` is a subgroup of the conformal orthogonal group not of type `"CGO", "GO", "SO"` or `"Omega"`. (Similarly for types `"ExtOmega+"` and `"ExtOmega-"`.)
##### `Example: Recognising a Unitary Group (ex-9f3ea6)`
```magma
> G := SU (60, 9);
> G := RandomConjugate (G);
> RecognizeClassical (G);
true
> IsLinearGroup (G);
false
> IsUnitaryGroup (G);
true
> IsSymplecticGroup (G);
false
> IsOrthogonalGroup (G);
false
> ClassicalType (G);
unitary
> G := Sp (462, 3);
> RecognizeClassical (G);
true
> ClassicalType (G);
symplectic
> ClassicalGroupType (G);
true Sp
> G := CGOPlus (14, 8);
> G := RandomConjugate (G);
> ClassicalGroupType (G);
true CGO+
```
#### Constructive Recognition of Linear Groups
The functions in this section recognise whether or not a given group $G$ is a specified linear group $T$. If it is, then an isomorphism between $G$ and $T$ is returned.
The function `ClassicalConstructiveRecognition` performs constructive recognition for all classical groups, and incorporates the recognition functions listed below for specific classical groups. See also `ExceptionalConstructiveRecognition` which deals with most finite exceptional groups of Lie type; the remaining cases – Suzuki groups, large and small Ree groups – are discussed here.
##### `RecognizeSL2(G): GrpMat -> BoolElt, Map, Map, Map, Map`
##### `RecogniseSL2(G): GrpMat -> BoolElt, Map, Map, Map, Map`
##### `RecognizeSL2(G): GrpPerm -> BoolElt, Map, Map, Map, Map`
##### `RecogniseSL2(G): GrpPerm -> BoolElt, Map, Map, Map, Map`
##### `RecognizeSL2(G, q): GrpMat, RngIntElt -> BoolElt, Map, Map, Map, Map`
##### `RecogniseSL2(G, q): GrpMat, RngIntElt -> BoolElt, Map, Map, Map, Map`
##### `RecognizeSL2(G, q): GrpPerm, RngIntElt -> BoolElt, Map, Map, Map, Map`
##### `RecogniseSL2(G, q): GrpPerm, RngIntElt -> BoolElt, Map, Map, Map, Map`
If $G$, a matrix or permutation group, is isomorphic, possibly modulo scalars, to $(P)SL(2, q)$, then homomorphisms between $G$ and $(P)SL(2, q)$ are constructed. The function returns a homomorphism from $G$ to $(P)SL(2, q)$, a homomorphism from $(P)SL(2, q)$ to $G$, the map from $G$ to its word group, and the map from the word group to $G$.
If $q$, the cardinality of the defining field for $G$, is known, it *should* be supplied. Otherwise, the function `SL2Characteristic` is used to determine $q$; if $q$ is large, this calculation may be **expensive**.
##### `SL2ElementToWord(G, g): GrpMat, GrpMatElt -> BoolElt, GrpSLPElt`
##### `SL2ElementToWord(G, g): GrpPerm, GrpPermElt -> BoolElt, GrpSLPElt`
If $g$ is an element of the matrix or permutation group $G$ which has been constructively recognised to have central quotient isomorphic to $PSL(2, q)$, then return `true` and element of word group for $G$ which evaluates to $g$, else `false`. This facilitates membership testing in $G$.
##### `SL2Characteristic(G : parameters): GrpMat -> RngIntElt, RngIntElt`
##### `SL2Characteristic(G : parameters): GrpPerm -> RngIntElt, RngIntElt`
```magma
NumberRandom: RngIntElt Default: 100
Verify : BoolElt Default: true
```
Subject to the *assumption* that the group $G$ has central quotient $(P)SL(2, q)$, determine its characteristic and field size. The Monte Carlo algorithm implemented by this function is that of Liebeck and O’Brien [[LO07](https://docs.magma-maths.org/references.md#cite-liebeck-obrien)]. Since it is Monte Carlo, there is a small probability of error. The number of random elements considered is `NumberRandom`. If `Verify` is `true`, then we first verify that $G$ is perfect by applying `IsProbablyPerfect`.
The constructive recognition algorithms for $SL(2, q)$ were developed by Conder, Leedham-Green, and O’Brien [[CLGO06](https://docs.magma-maths.org/references.md#cite-conder-lg-obrien)]. The algorithm used for other representations was developed by Brooksbank and O’Brien.
##### `Example: Recognising SL2 in Its Natural Representation (ex-6829cc)`
Our first example uses $G = {\operatorname{SL}}(2, 3^2)$ in its natural representation. We first recognise the group and then express a random matrix of $G$ as a word in the generators of $G$.
```magma
> G := SL(2, 3^2);
> flag, phi, tau, gamma, delta := RecogniseSL2(G, 3^2);
> g := G![1, 2, 0, 1];
> w := gamma(g);
> delta(w) eq g;
true
```
##### `Example: Recognising SL2 in Dimension 6 (ex-82f78a)`
We now consider a representation of a $2$-dimensional linear group inside $GL(6, {\bf F}_{5^7} )$.
```magma
> K := GF(5, 7);
> G :=
> MatrixGroup<6, GF(5, 7) |
> [w^19035, w^14713, w^50617, w^14957, w^51504, w^48397, w^16317, w^3829,
> w^35189, w^2473, w^19497, w^77192, w^46480, w^6772, w^29577, w^61815,
> w^54313, w^16757, w^43765, w^64406, w^58788, w^30789, w^13579, w^66728,
> w^7733, w^45434, w^42411, w^61613, w^12905, w^6889, w^50116, w^16117,
> w^56717, w^25226, w^49940, w^36836 ],
> [w^63955, w^40568, w^45004, w^11642, w^39536, w^11836, w^52594, w^71166,
> w^47015, w^74450, w^32373, w^37021, w^76381, w^18155, w^57943, w^31194,
> w^62524, w^65864, w^11868, w^76867, w^26483, w^41335, w^64856, w^41125,
> w^43990, w^40104, w^24842, w^3153, w^23777, w^60024, w^14454, w^68648,
> w^43403, w^26710, w^39779, w^22074 ] >;
>
> flag, phi, tau, gamma, delta := RecogniseSL2(G, 5^7);
> phi;
Mapping from: GrpMat: G to SL(2, GF(5, 7)) given by a rule [no inverse]
> g := Random(G);
> h := phi (g);
> h;
[w^40430 w^970]
[ w^5607 w^11606]
> k := tau(h);
> w := gamma(k);
> m := delta(w);
```
Recall that we are working modulo scalars.
```magma
> IsScalar(m * g^-1);
true
> H := SL(2, 5^7);
> h := H![1,1,0,1];
> g := tau(h);
> Order(g);
5
```
We now test a random element of $GL(6, {\bf F}_{5^7} )$ for membership of our group.
```magma
> g := Random(GL(6, 5^7));
> SL2ElementToWord(G, g);
false
```
##### `RecogniseSL3(G): GrpMat -> BoolElt, Map, Map, Map, Map`
##### `RecogniseSL3(G, q : parameters): GrpMat, RngIntElt -> BoolElt, Map, Map, Map, Map`
```magma
Verify: BoolElt Default: true
```
If $G \leq GL(d, F)$, is isomorphic, possibly modulo scalars, to $(P)SL(3, q)$, then construct homomorphisms between $G$ and $(P)SL(3, q)$. Return homomorphism from $G$ to $(P)SL(3, q)$, homomorphism from $(P)SL(3, q)$ to $G$, the map from $G$ to its word group and the map from the word group to $G$.
If $q$, the cardinality of the defining field for $G$, is known, it *should* be supplied. Otherwise, it is computed using the functions `LieCharacteristic` and `LieType`.
If `Verify` is `false`, then assume $G$ is isomorphic, possibly modulo scalars, to $(P)SL(3, q)$.
##### `SL3ElementToWord(G, g): GrpMat, GrpMatElt -> BoolElt, GrpSLPElt`
If $g$ is an element of $G$ which has been constructively recognised to have central quotient isomorphic to $PSL(3, q)$, then return `true` and element of word group for $G$ which evaluates to $g$, else `false`. This facilitates membership testing in $G$.
The constructive recognition algorithms for $SL(3, q)$ were developed by Lübeck, Magaard, and O’Brien [[LMO07](https://docs.magma-maths.org/references.md#cite-lubeck-magaard-obrien)]. Its current implementation, which is part of the `CompositionTree` package, was developed by Bäärnhielm and O’Brien.
##### `Example: Recognising SL3 and Its Symmetric Square (ex-46bbe9)`
We create $SL(3, 5^4)$ in its natural representation and recognise it. We then form its symmetric square and apply the recognition machinery to that.
```magma
> G := SL(3, 5^4);
> flag, phi, tau, gamma, delta := RecogniseSL3(G);
> w := PrimitiveElement (GF(5^4));
> g := GL(3, 5^4)! [1,2,1,0,w,1,0,0,w^-1];
> w := gamma (g);
> delta (w) eq g;
true
> G := ActionGroup(SymmetricSquare(GModule(G)));
> flag, phi, tau, gamma, delta := RecogniseSL3(G);
> phi;
Mapping from: GL(6, GF(5, 4)) to SL(3, GF(5, 4)) given by a rule [no inverse]
> g := Random(G);
> h := phi(g);
> h;
[$.1^40430 $.1^970]
[ $.1^5607 $.1^11606]
> k := tau(h);
> w := gamma(k);
> m := delta(w);
```
Recall that we are working modulo scalars. We conclude by testing whether a random element of $GL(6, 5^4)$ is contained in our group.
```magma
> IsScalar(m * g^-1);
true
> g := Random(GL(6, 5^4));
> SL3ElementToWord(G, g);
false
```
##### `RecogniseSL(G, d, q): Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map`
##### `RecognizeSL(G, d, q): Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map`
Use the Kantor-Seress algorithm to try to find an isomorphism between the finite group $G$ (regarded as a black-box group) and $\SL(d,q)$ or $\PSL(d,q)$. The first return value indicates whether the attempt was successful. If so, then the second and third return values are mutually inverse homomorphisms (modulo scalars if $G \cong \PSL(d,q)$) from $G$ to $\SL(d,q)$ and from $\SL(d,q)$ to $G$.
*Warning*: This function often returns `false` even when $G$ is isomorphic to $\SL(d,q)$ or $\PSL(d,q)$, so it should be called repeatedly until it returns `true`!
#### Constructive Recognition of Symplectic Groups
##### `RecogniseSpOdd(G, d, q): Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map`
##### `RecognizeSpOdd(G, d, q): Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map`
Use the Kantor-Seress algorithm to try to find an isomorphism between the finite group $G$ (regarded as a black-box group) and $\Sp(d,q)$ or $\PSp(d,q)$ for odd $q$. The first return value indicates whether the attempt was successful. If so, then the second and third return values are mutually inverse homomorphisms (modulo scalars if $G \cong \PSp(d,q)$) from $G$ to $\Sp(d,q)$ and from $\Sp(d,q)$ to $G$.
*Warning*: This function often returns `false` even when $G$ is isomorphic to $\Sp(d,q)$ or $\PSp(d,q)$, so it should be called repeatedly until it returns `true`!
##### `RecogniseSp4(G, q): Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map, Map, Map, SeqEnum, SeqEnum`
##### `RecognizeSp4(G, q): Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map, Map, Map, SeqEnum, SeqEnum`
Use an algorithm of Peter Brooksbank to try to find an isomorphism between the finite group $G$ (regarded as a black-box group) and $\Sp(4,q)$. The first return value indicates whether the attempt was successful. If so, then the second and third return values are mutually inverse homomorphisms from $G$ to (P)$\Sp(d,q)$ and from (P)$\Sp(d,q)$ to $G$. The fourth and fifth return values are mutually inverse homomorphisms from $G$ to the word group $W$ of $G$ and from $W$ to $G$. The sixth and seventh return values are standard generators for $G$ and straight-line programs for these generators in the generators of $G$.
#### Constructive Recognition of Unitary Groups
##### `RecogniseSU3(G, d, q): Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map`
##### `RecognizeSU3(G, d, q): Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map`
Use an algorithm of Peter Brooksbank to try to find an isomorphism between the finite group $G$ (regarded as a black-box group) and $\SU(3,q)$ or $\PSU(3,q)$ for $q>2$. The first return value indicates whether the attempt was successful. If so, then the second and third return values are mutually inverse homomorphisms (modulo scalars if $G \cong \PSU(3,q)$) from $G$ to $\SU(3,q)$ and from $\SU(3,q)$ to $G$. The third and fourth return values are mutually inverse homomorphisms from $G$ to the word group $W$ of $G$ and from $W$ to $G$.
##### `RecogniseSU4(G, d, q): Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map`
##### `RecognizeSU4(G, d, q): Grp, RngIntElt, RngIntElt -> BoolElt, Map, Map`
Use an algorithm of Peter Brooksbank to try to find an isomorphism between the finite group $G$ (regarded as a black-box group) and $\SU(4,q)$ or $\PSU(4,q)$. The first return value indicates whether the attempt was successful. If so, then the second and third return values are mutually inverse homomorphisms (modulo scalars if $G \cong \PSU(4,q)$) from $G$ to $\SU(4,q)$ and from $\SU(4,q)$ to $G$. The third and fourth return values are mutually inverse homomorphisms from $G$ to the word group $W$ of $G$ and from $W$ to $G$.
#### Recognition Of Classical Groups in Low Degree
Let $H$ be a perfect classical group of degree $d$, and let $H$ act absolutely irreducibly on a defining characteristic module $W$ of dimension at most $d^2$.
Magaard, O’Brien & Seress [[MOAS08](https://docs.magma-maths.org/references.md#cite-small-deg-reps)] and Brian Corr [[Cor13](https://docs.magma-maths.org/references.md#cite-corr-phd)] and Csaba Schneider (in preparation) describe algorithms which, given as input the representation of $H$ on $W$, construct a $d$-dimensional projective representation of $H$.
Schneider’s algorithms, and his implementations, are used for the exterior and symmetric square representations of $H$; those of [[MOAS08](https://docs.magma-maths.org/references.md#cite-small-deg-reps)], [[Cor13](https://docs.magma-maths.org/references.md#cite-corr-phd)], and their implementation prepared by Brian Corr and Eamonn O’Brien, are used for the other cases.
Note that the algorithms have various limitations in terms of type of group, degree $d$, and defining field size; if an algorithm does not apply to the input case, it returns `false`.
##### `RecogniseSmallDegree(G): GrpMat -> BoolElt, GrpMat`
##### `RecogniseSmallDegree(G, type, d, q): GrpMat, MonStgElt, RngIntElt, RngIntElt -> BoolElt, GrpMat, Map, Map`
If $G$ is a perfect defining characteristic absolutely irreducible representation of a classical group $H$ of degree $d$ and $G$ has degree in $[d + 1, \ldots, d^2]$, then return `true`, $H$, map from $H$ to $G$, and map from $G$ to $H$; otherwise return `false`.
In the second signature, we supply the information that $H$ has degree $d$, defining field ${\bf F}_{q}$, and its type is one of `SL, Sp, SU, Omega, Omega+, Omega-`.
##### `SmallDegreePreimage(G, g): GrpMat, GrpMatElt -> GrpMatElt`
The group $G$ is a perfect defining characteristic absolutely irreducible representation of a classical group $H$ of small degree, to which `RecogniseSmallDegree` has been successfully applied; if $g$ is in $G$, return `true` and a preimage of $g$ in $H$, otherwise `false`.
##### `SmallDegreeImage(G, h): GrpMat, GrpMatElt -> GrpMatElt`
The group $G$ is a perfect defining characteristic absolutely irreducible representation of a classical group $H$ of small degree, to which `RecogniseSmallDegree` has been successfully applied; if $h$ is in $H$, return `true` and the image of $h$ in $G$, otherwise `false`. Note that `SmallDegreePreimage` and this function are inverses only up to a choice of scalars.
##### `Example: Recognising SL4 in a Symmetric Square (ex-5df193)`
```magma
> G := SL(4, 9);
> M := GModule (G);
> M := SymmetricPower (M, 2);
> G := MatrixGroup (M);
> G := RandomConjugate (G);
> flag, H := RecogniseSmallDegree (G, "SL", 4, 9);
> flag;
true
> H;
MatrixGroup(4, GF(3^2))
Generators:
[ 0 1 0 0]
[ 0 0 0 1]
[$.1^6 2 2 $.1]
[ 2 $.1 0 $.1]
[ 0 0 1 0]
[$.1^2 $.1^7 1 $.1^6]
[ 1 2 $.1^6 $.1^6]
[ $.1 0 $.1^7 0]
> g := Random (G);
> flag, h := SmallDegreePreimage (G, g);
> h;
[$.1^6 0 0 $.1^2]
[$.1^6 0 $.1^3 0]
[$.1^2 $.1^5 2 $.1]
[ 0 $.1^3 $.1^5 $.1]
> flag, gbar := SmallDegreeImage (G, h);
> flag;
true
> IsScalar (g * gbar^-1);
true
```
#### Constructive Recognition of Suzuki Groups
##### Introduction
A description of the functionality for constructive recognition and constructive membership testing of the Suzuki groups ${\rm Sz}(q)$, with $q = 2^{2m + 1}$ for some $m > 0$ follows.
The main intrinsics of the package are `RecogniseSz(G)` which performs constructive recognition of $G \cong {\rm Sz}(q)$, `SzElementToWord(G, g)` which returns a `GrpSLPElt` for $g$ in the generators of $G$, and `IsSuzukiGroup(G)` which is a non-constructive test for isomorphism between $G$ and ${\rm Sz}(q)$.
Informative printing can be obtained using one of a number of verbose flags:
**•**
$\quad$ `SuzukiGeneral`, for the general routines.
**•**
$\quad$ `SuzukiStandard`, for the routines related to the standard copy.
**•**
$\quad$ `SuzukiConjugate`, for the routines related to conjugation.
**•**
$\quad$ `SuzukiTensor`, for the routines related to tensor decomposition.
**•**
$\quad$ `SuzukiMembership`, for the routines related to membership testing.
**•**
$\quad$ `SuzukiCrossChar`, for the routines related to cross-characteristic representations.
**•**
$\quad$ `SuzukiTrick`, for the routines related to the double coset trick.
**•**
$\quad$ `SuzukiNewTrick`, for the routines related to the stabiliser trick.
For each of the flags, the verbose level takes any value up to $10$, with higher values resulting in more output.
##### Recognition Functions
###### `IsSuzukiGroup(G): GrpMat -> BoolElt, RngIntElt`
Given a matrix group $G$, this function determines (non-constructively) whether or not $G$ is isomorphic to ${\rm Sz}(q)$. The corresponding finite field cardinality $q$ is also returned.
If the group $G$ is defined over a field of odd characteristic or has degree greater than $4$, the Monte Carlo algorithm of [`LieType`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-grpmatff-lietype) is used. If $G$ has degree $4$ and is over a field of characteristic $2$, then a fast Las Vegas algorithm is used, described in [[Baa06a](https://docs.magma-maths.org/references.md#cite-baarnhielm05)].
###### `RecogniseSz(G : parameters): GrpMat -> BoolElt, Map, Map, Map, Map`
###### `RecognizeSz(G : parameters): GrpMat -> BoolElt, Map, Map, Map, Map`
```magma
Verify : BoolElt Default: true
FieldSize: RngIntElt Default:
Optimise : BoolElt Default: false
```
Let $G$ be a group that is absolutely irreducible and is defined over a minimal field. This function constructively recognises $G$ as a Suzuki group. If $G$ is isomorphic to ${\rm Sz}(q)$, where $q$ is the size of the defining field of $G$, then return:
**•**
Isomorphism from $G$ to ${\rm Sz}(q)$.
**•**
Isomorphism from ${\rm Sz}(q)$ to $G$.
**•**
Map from $G$ to the word group of $G$.
**•**
Map from the word group of $G$ to $G$.
The isomorphisms are composed of maps that are defined by rules, so `Function` should be used on each component to avoid unnecessary built-in membership testing. The word group is the `GrpSLP` group which is the parent of the elements returned by `SzElementToWord`. In general this is not the same as `WordGroup(G)`, but is created from it using `AddRedundantGenerators`.
If `Verify` is true, then it is checked if $G$ is isomorphic to ${\rm Sz}(q)$, using `IsSuzukiGroup`. In that case, `FieldSize` must be set to the correct value of $q$. Constructive recognition of $2.{\rm Sz}(8)$ is also handled.
If `Optimise` is true, then the third map returns element in an optimised word group (using `AddRedundantGenerators`). Then each invocation of the map will be faster, but the initialisation will take longer.
The algorithms used for constructive recognition are described in [[Baa06a](https://docs.magma-maths.org/references.md#cite-baarnhielm05)] and [[Baa05](https://docs.magma-maths.org/references.md#cite-sz-tensor-decompose)].
###### `SzElementToWord(G, g): GrpMat, GrpMatElt -> BoolElt, GrpSLPElt`
If $G$ has been constructively recognised as a Suzuki group, and if $g$ is an element of $G$, then return `true` and a `GrpSLPElt` from the word group of $G$ which evaluates to $g$, else return `false`.
This facilitates membership testing in $G$.
###### `SzPresentation(q): RngIntElt -> GrpFP, HomGrp`
If $q = 2^{2m + 1}$ for some $m > 0$, return a short presentation of ${\rm Sz}(q)$ on the Magma standard generators, i.e. the generators returned by the `Sz` intrinsic.
###### `SatisfiesSzPresentation(G): GrpMat -> BoolElt`
$G$ is constructively recognised as ${\rm Sz}(q)$ for some $q$. Verify that it satisfies a presentation for this group.
###### `SuzukiIrreducibleRepresentation(F, twists : parameters): FldFin, SeqEnum[RngIntElt] -> GrpMat`
```magma
CheckInput: BoolElt Default: true
```
Let $F$ be a finite field of cardinality $q = 2^{2m + 1}$ for some $m > 0$, and let *twists* be a sequence of $n$ distinct integers in the range $[0 \ldots 2m]$. The function returns an absolutely irreducible representation of ${\rm Sz}(q)$ having dimension $4^n$, being a tensor product of twisted powers of the copy returned by the `Sz` intrinsic, where the twists are given by the input sequence.
If `CheckInput` is true, then it is verified that $F$ and *twists* satisfy the above requirements. Otherwise this is not checked.
###### `Example: Recognising the Suzuki Group Sz(32) (ex-9d33f6)`
We illustrate the basic facilities starting with a random conjugate of the standard version of the Suzuki group $Sz(32)$. We first perform non-constructive recognition.
```magma
> G := Sz(32);
> G ^:= Random(Generic(G));
> flag, q := SuzukiRecognition(G);
> flag, q eq 32;
true true
```
The next step is to perform constructive recognition. The explicit isomorphisms will be the values of `iso` and `inv`.
```magma
> flag, iso, inv, g2slp, slp2g := RecognizeSz(G);
> flag;
true
> iso, inv;
Mapping from: GrpMat: G to MatrixGroup(4, GF(2^5)) given by a rule [no inverse]
Mapping from: MatrixGroup(4, GF(2^5)) to GrpMat: G given by a rule [no inverse]
```
We now experiment with membership testing. We use Function to avoid Magma’s built-in membership testing but in doing so, we may not obtain the shortest possible SLP.
```magma
> w := Function(g2slp)(G.1);
> #w;
284
```
The algorithm is probabilistic, so different executions will most likely give different results.
```magma
> ww := Function(g2slp)(G.1);
> w eq ww;
false
```
Note that the resulting SLPs are from a word group that is not the word group $W$ corresponding to the defining generators of $G$. However, they can be coerced into $W$.
```magma
> W := WordGroup(G);
> NumberOfGenerators(Parent(w)), NumberOfGenerators(W);
7 3
> flag, ww := IsCoercible(W, w);
> flag;
true
> slp2g(w) eq Evaluate(ww, UserGenerators(G));
true
```
So there are two ways to get the element back. An alternative is to use the intrinsic `SzElementToWord`, which is better if the elements are not known to lie in the group.
```magma
> flag, ww := SzElementToWord(G, G.1);
> flag, slp2g(w) eq slp2g(ww);
true true
```
We take an element just outside the group.
```magma
> H := Sp(4, 32);
> flag, ww := SzElementToWord(G, H.1);
> flag;
false
> // in this case we will not get an SLP
> ww := Function(g2slp)(H.1);
> ww;
false
> SatisfiesSzPresentation(G);
true
```
###### `Example: Constructive Membership in 2.Sz(8) (ex-d3b056)`
As a variation we apply the machinery to $2.Sz(8)$. We demonstrate constructive recognition and constructive membership testing.
```magma
> A := ATLASGroup("2Sz8");
> reps := MatRepKeys(A);
> G := MatrixGroup(reps[3]);
> Degree(G), CoefficientRing(G);
40 Finite field of size 7
> flag, iso, inv, g2slp, slp2g := RecognizeSz(G);
> flag;
true
> R := RandomProcess(G);
> g := Random(R);
> w := Function(g2slp)(g);
> slp2g(w) eq g;
true
```
###### `Example: Suzuki Group in Dimension 64 (ex-f8d565)`
For the next example we consider a case where the dimension is large. We construct the Suzuki group in a 64-dimensional matrix representation and then take a random conjugate and also rewrite is over a smaller field.
```magma
> F := GF(2, 9);
> twists := [0, 3, 6];
> G := SuzukiIrreducibleRepresentation(F, twists);
> Degree(G), IsAbsolutelyIrreducible(G);
64 true
> G ^:= Random(Generic(G));
> flag, GG := IsOverSmallerField(G);
> flag, CoefficientRing(GG);
true Finite field of size 2^3
```
Non-constructive recognition is harder in this case and will give us the defining field size. Constructive recognition will decompose the tensor product.
```magma
> time SuzukiRecognition(GG);
true 512
Time: 2.330
> time flag, iso, inv, g2slp, slp2g := RecogniseSz(GG);
Time: 4.800
> iso;
Mapping from: GrpMat: GG to MatrixGroup(4, GF(2^9)) given by a rule [no inverse]
```
Constructive membership is again easy
```magma
> R := RandomProcess(GG);
> g := Random(R);
> time w := Function(g2slp)(g);
Time: 0.020
> // but SLP evaluation is harder in large dimensions
> time slp2g(w) eq g;
true
Time: 0.370
> time SatisfiesSzPresentation(GG);
true
Time: 10.930
```
###### `Example: Suzuki Group in Cross Characteristic (ex-183108)`
The final example will be in cross characteristic. We build a representation of $Sz(8)$ in cross characteristic.
```magma
> G := Sz(8);
> _, P := SuzukiPermutationRepresentation(G);
> // for example over GF(9)
> M := PermutationModule(P, GF(3, 2));
> factors := CompositionFactors(M);
> exists(m64){f : f in factors | Dimension(f) eq 64};
true
> m64;
GModule m64 of dimension 64 over GF(3^2)
> H := ActionGroup(m64);
> IsAbsolutelyIrreducible(H);
true
> flag, G := IsOverSmallerField(H);
> Degree(G), CoefficientRing(G);
64 Finite field of size 3
```
We actually end up with a group in characteristic $3$.
```magma
> time flag, iso, inv, g2slp, slp2g := RecogniseSz(G);
Time: 3.490
> iso;
Mapping from: GrpMat: G to MatrixGroup(4, GF(2^3)) given by a rule [no inverse]
> R := RandomProcess(G);
> g := Random(R);
> time w := Function(g2slp)(g);
Time: 0.010
> time slp2g(w) eq g;
true
Time: 0.110
> time SatisfiesSzPresentation(G);
true
Time: 0.330
```
#### Constructive Recognition of Small Ree Groups
##### Introduction
This machinery provides functionality for constructive recognition and constructive membership testing of the small Ree groups ${\rm {^2}G_2}(q) = {\rm Ree}(q)$, with $q = 3^{2m + 1}$ for some $m > 0$.
The important intrinsics are `RecogniseRee` which performs constructive recognition of $G \cong {\rm Ree}(q)$, `ReeElementToWord` which returns a `GrpSLPElt` for $g$ in the generators of $G$, and `IsReeGroup` which is a non-constructive test for isomorphism between $G$ and ${\rm Ree}(q)$.
There are a few verbose flags used in the package.
**•**
$\quad$ `ReeGeneral`, for the general routines.
**•**
$\quad$ `ReeStandard`, for the routines related to the standard copy.
**•**
$\quad$ `ReeConjugate`, for the routines related to conjugation.
**•**
$\quad$ `ReeTensor`, for the routines related to tensor decomposition.
**•**
$\quad$ `ReeMembership`, for the routines related to membership testing.
**•**
$\quad$ `ReeCrossChar`, for the routines related to cross-characteristic representations.
**•**
$\quad$ `ReeTrick`, for the routines related to the stabiliser trick.
**•**
$\quad$ `ReeInvolution`, for the routines related to involution centralisers.
**•**
$\quad$ `ReeSymSquare`, for the routines related to symmetric square decomposition.
All the flags can be set to values up to $10$, with higher values resulting in more output.
##### Recognition Functions
###### `RecogniseRee(G : parameters): GrpMat -> BoolElt, Map, Map, Map, Map`
###### `RecognizeRee(G : parameters): GrpMat -> BoolElt, Map, Map, Map, Map`
```magma
Verify : BoolElt Default: true
FieldSize: RngIntElt Default:
Optimise : BoolElt Default: false
```
The matrix group $G$ is absolutely irreducible and defined over minimal field. Constructively recognise $G$ as a Ree group. If $G$ is isomorphic to ${\rm Ree}(q)$ where $q$ is the size of the defining field of $G$, then return:
**•**
Isomorphism from $G$ to ${\rm Ree}(q)$.
**•**
Isomorphism from ${\rm Ree}(q)$ to $G$.
**•**
Map from $G$ to the word group of $G$.
**•**
Map from the word group of $G$ to $G$.
The isomorphisms are composed of maps that are defined by rules, so `Function` should be used on each component to avoid unnecessary built-in membership testing.
The word group is the `GrpSLP` which is the parent of the elements returned by `ReeElementToWord`. In general this is not the same as `WordGroup(G)`, but is created from it using `AddRedundantGenerators`.
If `Verify` is true, then it is checked that $G$ is isomorphic to ${\rm Ree}(q)$, using `IsReeGroup`, otherwise this is not checked. In that case, `FieldSize` must be set to the correct value of $q$.
If `Optimise` is true, then the third map returns element in an optimised word group (using `AddRedundantGenerators`). Then each invocation of the map will be faster, but the initialisation will take longer.
The algorithm for constructive recognition is described in [[Baa14](https://docs.magma-maths.org/references.md#cite-baarnhielm14)].
###### `ReeElementToWord(G, g): GrpMat, GrpMatElt -> BoolElt, GrpSLPElt`
If $G$ has been constructively recognised as a Ree group, and if $g$ is an element of $G$, then return `true` and a `GrpSLPElt` from the word group of $G$ which evaluates to $g$, else return `false`.
This facilitates membership testing in $G$.
###### `IsReeGroup(G): GrpMat -> BoolElt, RngIntElt`
Determine (non-constructively) if $G$ is isomorphic to ${\rm Ree}(q)$. The corresponding $q$ is also returned.
If $G$ is over a field of characteristic not $3$ or has degree greater than $7$, the Monte Carlo algorithm of [`LieType`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-grpmatff-lietype) is used. If $G$ has degree $7$ and is over a field of characteristic $3$, then a fast Las Vegas algorithm is used.
###### `ReeIrreducibleRepresentation(F, twists : parameters): FldFin, SeqEnum[RngIntElt] -> GrpMat`
```magma
CheckInput: BoolElt Default: true
```
The finite field $F$ must have size $q = 3^{2m + 1}$ for some $m > 0$, and *twists* should be a sequence of $n$ distinct pairs of integers $(i, j)$ where $i$ is $7$ or $27$ and $j$ in the range $[0 \ldots 2m]$.
Return an absolutely irreducible representation of ${\rm Ree}(q)$, a tensor product of twisted powers of the representation of dimension $7$ or $27$, where the twists are given by the input sequence.
If `CheckInput` is `true`, then it is verified that $F$ and *twists* satisfy the above requirements. Otherwise this is not checked.
###### `Example: Recognising a Ree Group (ex-79d9a3)`
Our first example shows off the recognition machinery for the Ree group defined over ${\bf F}_{27}$.
```magma
> SetSeed(1);
> F := GF(3, 3);
> G := ReeGroup(F);
> G ^:= Random(Generic(G));
> flag, q := ReeRecognition(G);
> flag, q eq #F;
true true
> flag, iso, inv, g2slp, slp2g := RecognizeRee(G);
> flag;
true
> iso, inv;
Mapping from: GrpMat: G to MatrixGroup(7, GF(3^3)) given by a rule [no inverse]
Mapping from: MatrixGroup(7, GF(3^3)) to GrpMat: G given by a rule [no inverse]
```
We now experiment with membership testing. As the algorithm is probabilistic, different executions will most likely give different results.
```magma
> w := Function(g2slp)(G.1);
> #w;
342
> ww := Function(g2slp)(G.1);
> w eq ww;
false
```
The resulting SLPs are from another word group but can be coerced into $W$.
```magma
> W := WordGroup(G);
> NumberOfGenerators(Parent(w)), NumberOfGenerators(W);
7 3
> flag, ww := IsCoercible(W, w);
> flag;
true
> // so there are two ways to get the element back
> slp2g(w) eq Evaluate(ww, UserGenerators(G));
true
```
If the elements are not known to lie in the group, a better alternative is to use the intrinsic `ReeElementToWord`. We take a generator of $\Omega(7, F)$ as an example of an element not lying in $G_2(27)$.
```magma
> flag, ww := ReeElementToWord(G, G.1);
> flag, slp2g(w) eq slp2g(ww);
true true
> H := Omega(7, #F);
> flag, ww := ReeElementToWord(G, H.1);
> flag;
false
> ww := Function(g2slp)(H.1);
> ww;
false
```
#### Constructive Recognition of Large Ree Groups
##### Introduction
This machinery provides functionality for constructive recognition and constructive membership testing of the large Ree groups ${\rm {^2}F_4}(q) = {\rm LargeRee}(q)$, with $q = 2^{2m + 1}$ for some $m > 0$.
The important intrinsics are `RecogniseLargeRee` which performs constructive recognition of $G \cong {\rm LargeRee}(q)$, `LargeReeElementToWord` which returns a `GrpSLPElt` for $g$ in the generators of $G$, and `IsLargeReeGroup` which is a non-constructive test for isomorphism between $G$ and ${\rm LargeRee}(q)$.
There are a few verbose flags used in the package.
**•**
$\quad$ `LargeReeGeneral`, for the general routines.
**•**
$\quad$ `LargeReeStandard`, for the routines related to the standard copy.
**•**
$\quad$ `LargeReeConjugate`, for the routines related to conjugation.
**•**
$\quad$ `LargeReeRyba`, for the routines related to membership testing.
**•**
$\quad$ `LargeReeTrick`, for the routines related to the stabiliser trick.
**•**
$\quad$ `LargeReeInvolution`, for the routines related to involution centralisers.
**•**
$\quad$
All the flags can be set to values up to $10$, with higher values resulting in more output.
##### Recognition Functions
###### `RecogniseLargeRee(G : parameters): GrpMat -> BoolElt, Map, Map, Map, Map`
###### `RecognizeLargeRee(G : parameters): GrpMat -> BoolElt, Map, Map, Map, Map`
```magma
Verify : BoolElt Default: true
FieldSize: RngIntElt Default:
Optimise : BoolElt Default: false
```
The matrix group $G$ is absolutely irreducible and defined over minimal field. Constructively recognise $G$ as a Large Ree group. If $G$ is isomorphic to ${\rm LargeRee}(q)$ where $q$ is the size of the defining field of $G$, then return:
**•**
Isomorphism from $G$ to ${\rm LargeRee}(q)$.
**•**
Isomorphism from ${\rm LargeRee}(q)$ to $G$.
**•**
Map from $G$ to the word group of $G$.
**•**
Map from the word group of $G$ to $G$.
The isomorphisms are composed of maps that are defined by rules, so `Function` should be used on each component to avoid unnecessary built-in membership testing.
The word group is the `GrpSLP` which is the parent of the elements returned by `LargeReeElementToWord`. In general this is not the same as `WordGroup(G)`, but is created from it using `AddRedundantGenerators`.
If `Verify` is true, then it is checked that $G$ is isomorphic to ${\rm LargeRee}(q)$, using `IsLargeRee`, otherwise this is not checked. In that case, `FieldSize` must be set to the correct value of $q$.
If `Optimise` is true, then the third map returns element in an optimised word group (using `AddRedundantGenerators`). Then each invocation of the map will be faster, but the initialisation will take longer.
###### `LargeReeElementToWord(G, g): GrpMat, GrpMatElt -> BoolElt, GrpSLPElt`
If $G$ has been constructively recognised as a Large Ree group, and if $g$ is an element of $G$, then return `true` and a `GrpSLPElt` from the word group of $G$ which evaluates to $g$, else return `false`.
This facilitates membership testing in $G$.
###### `IsLargeReeGroup(G): GrpMat -> BoolElt, RngIntElt`
Determine (non-constructively) if $G$ is isomorphic to ${\rm LargeRee}(q)$. The corresponding $q$ is also returned.
If $G$ is over a field of characteristic not $2$ or has degree greater than $26$, the Monte Carlo algorithm of [`LieType`](https://docs.magma-maths.org/FiniteGroups/AlmostSimpleGroups/group-recognition.md#function-grpmatff-lietype) is used. If $G$ has degree $26$ and is over a field of characteristic $2$, then a fast Las Vegas algorithm is used.
### Properties of Finite Groups Of Lie Type
#### Maximal Subgroups of the Classical Groups
The `ClassicalMaximals` function, written by Derek Holt and Colva Roney-Dougal, returns a list of the maximal subgroups of the classical quasisimple groups in their natural representations, as returned by the Magma functions `SL, Sp, SU, Omega, OmegaPlus, OmegaMinus`. The list should be complete for dimensions up to 17. For larger dimensions, all maximal subgroups of geometric type are returned, but not those of Type S (sometimes known as Class C9).
There are also options to return the normalisers of these subgroups in various groups, such as ${\rm GL}(n,q)$, ${\rm CU}(n,q)$, that lie between the quasisimple group and its normaliser in the general linear group. These should be sufficient to enable the skilled user to determine the maximal subgroups of any group lying between the quasisimple groups and its normaliser.
Alternatively, the `type` parameter can now be one of `SL, GL, Sp, SU, GU, Omega+, Omega-, Omega, SO+, SO-, SO, GO+, GO-` (as in the intrinsic `ClassicalClasses`), in which case representatives of the conjugacy classes of the maximal subgroups of the corresponding classical group are returned. For these cases all the optional parameters are ignored.
According to the theorem of Aschbacher [[Asc84](https://docs.magma-maths.org/references.md#cite-asch-maximal-subgps)] discussed earlier in this chapter, the maximal subgroups of a quasisimple classical group over a finite field lie in (at least) one of nine categories, which were listed in the Aschbacher Reduction section.
The subgroups in the first eight of these categories are said to be of *geometric type* and can be described in a uniform fashion. This description is the topic of the book [[KL90](https://docs.magma-maths.org/references.md#cite-kl90)]. They are returned in all dimensions by `ClassicalMaximals`. There is no such uniform description of the subgroups in the ninth class, which have to be classified separately in each dimension. The lists in the papers [[HM01](https://docs.magma-maths.org/references.md#cite-hiss-malle)], [[HM02](https://docs.magma-maths.org/references.md#cite-hiss-malle-c)], and [[Lub01](https://docs.magma-maths.org/references.md#cite-luebeck)] contain sufficient information in theory to compute these subgroups up to dimension 250, but currently this has been carried out only up to dimension 17.
##### `ClassicalMaximals(type, d, q : parameters): MonStgElt, RngIntElt, RngIntElt -> SeqEnum`
```magma
classes : SetEnum Default: {1 ... 9}
all : BoolElt Default: true
special : BoolElt Default: false
general : BoolElt Default: false
normaliser: BoolElt Default: false
novelties : BoolElt Default: false
```
Return a list of representatives of the conjugacy classes of maximal subgroups of the quasisimple group of the specified type in dimension $d$ over the field of order $q$. The string *type* must either be one of `L, S, U, O, O+, O-`, or one of `SL, GL, Sp, SU, GU, Omega+, Omega-, Omega, SO+, SO-, SO, GO+, GO-`. For this second set of possible types, the optional paramaters described below are ignored. For example `ClassicalMaximals("GU",d,q)` simply returns a list of representatives of the conjugacy classes of the maximal subgroups of $\GU(d,q)$ (which may be incomplete when $d>17$).
If the optional parameter `classes` is set to a proper subset of $\{1 \ldots 9\}$, then only the subgroups lying in the corresponding Aschbacher categories will be returned.
If the option `all` is set `false`, then representatives of the conjugacy classes under the action of the full automorphism group of the simple classical group will be returned: so this option will usually result in fewer subgroups in the returned list!
The option `special` only has effect for types `O, O+, O-`. When this is set to `true`, the normalisers of the subgroups in the appropriate group ${\rm SO}(d,q)$, ${\rm SO}^+(d,q)$, or ${\rm SO}^-(d,q)$ will be returned.
If the option `general` is set to `true`, then the normalisers of the subgroups in the appropriate group ${\rm GL}(d,q)$, ${\rm GU}(d,q)$, ${\rm GO}(d,q)$, ${\rm GO}^+(d,q)$, or ${\rm GO}^-(d,q)$ will be returned. (This option has no effect for type `S`.)
If the option `normaliser` is set to `true`, then the normalisers of the subgroups in the full normaliser of the quasisimple group in the general linear group (i.e. the group preserving the relevant form modulo scalars) will be returned. (For type `L` this has the same effect as setting *general* to `true`.)
If the option `novelties` is set `true`, then the intersections with the quasisimple group of any novelty maximal subgroups of any groups lying between the simple group and its full automorphism group will be returned. Use this option with caution, because the results are not guaranteed to be reliable!
#### Maximal Subgroups of the Exceptional Groups
Here are some intrinsics for creating and conjugating maximal subgroups of Suzuki and Ree groups. The flags `SuzukiMaximals` and `ReeMaximals` may be used to produce verbose output.
##### `SuzukiMaximalSubgroups(G): GrpMat -> SeqEnum, SeqEnum`
If $G$ has been constructively recognised as a Suzuki group, return a sequence of representatives of the maximal subgroups of $G$. Also returns sequences of `GrpSLPElt` of the generators of the subgroups, from the word group of $G$.
##### `SuzukiMaximalSubgroupsConjugacy(G, R, S): GrpMat, GrpMat, GrpMat -> GrpMatElt, GrpSLPElt`
If $G$ has been constructively recognised as a Suzuki group and if $R$ and $S$ are conjugate maximal subgroups of $G$, then return an element $g$ of $G$ that conjugates $R$ to $S$. A `GrpSLPElt` from the word group of $G$, that evaluates to $g$, is also returned.
##### `ReeMaximalSubgroups(G): GrpMat -> SeqEnum, SeqEnum`
If $G$ has been constructively recognised as a Ree group, return a sequence of representatives of the maximal subgroups of $G$. Also returns sequences of `GrpSLPElt` of the generators of the subgroups, from the word group of $G$.
##### `ReeMaximalSubgroupsConjugacy(G, R, S): GrpMat, GrpMat, GrpMat -> GrpMatElt, GrpSLPElt`
If $G$ has been constructively recognised as a Ree group and if $R$ and $S$ are conjugate maximal subgroups of $G$, then return an element $g$ of $G$ that conjugates $R$ to $S$. A `GrpSLPElt` from the word group of $G$, that evaluates to $g$, is also returned. This is not implemented if $R, S$ are Frobenius groups.
##### `SzMaximals(q): RngIntElt -> SeqEnum`
Representatives of the conjugacy classes of maximal subgroups of the Suzuki groups ${\rm Sz}(q)$ (where $q>2$ is an odd power of $2$) are returned. They are subgroups of the subgroup of ${\rm GL}(4,q)$ returned by the Magma function `Sz(q)`.
##### `ReeMaximals(q): RngIntElt -> SeqEnum`
Representatives of the conjugacy classes of maximal subgroups of the small Ree groups ${\rm Ree}(q)$ (where $q>3$ is an odd power of $3$) are returned. They are subgroups of the subgroup of ${\rm GL}(7,q)$ returned by the Magma function `Ree(q)`.
##### `G2Maximals(q): RngIntElt -> SeqEnum`
Representatives of the conjugacy classes of maximal subgroups of the groups $G_2(q)$ (where $q$ is prime power) are returned. They are subgroups of the subgroup of ${\rm GL}(7,q)$ returned by the Magma function `G2(q)`.
#### Sylow Subgroups of the Classical Groups
The Magma ClassicalSylow package written by Mark Stather provides functionality for constructing and conjugating the Sylow $p$-subgroups of the classical groups over finite fields in their natural representation, for any prime $p$. The classical groups may be created in Magma using the `GL, SL, Sp, GO, GOPlus, GOMinus, SO, SOPlus, SOMinus, Omega, OmegaPlus, OmegaMinus, GU, SU` intrinsics.
This package makes use of code to compute the classical form fixed by a group written by Derek Holt, and code to conjugate classical forms written by Colva Roney-Dougal.
The algorithms in this package are described in [[Sta](https://docs.magma-maths.org/references.md#cite-stather)], which in turn makes use of the descriptions of the Sylow subgroups of the classical groups given in [[Wei55](https://docs.magma-maths.org/references.md#cite-we55)], [[CF64](https://docs.magma-maths.org/references.md#cite-caf64)], [[RRe57](https://docs.magma-maths.org/references.md#cite-ree57)], and [[Car72a](https://docs.magma-maths.org/references.md#cite-car72)]. The conjugation algorithms make use of only the Meataxe, Smash, basic linear algebra, and the solution of norm equations over finite fields.
##### `ClassicalSylow(G, p): GrpMat, RngIntElt -> GrpMat`
The argument $G$ must be a classical group in its natural representation, up to conjugation, with the exception of $GO(2m+1,2^e)$. More precisely, it must be a conjugate of a group returned by one of the intrinsics `GL, SL, Sp, GO, GOPlus, GOMinus, SO, SOPlus, SOMinus, Omega, OmegaPlus, OmegaMinus, GU, SU` and $p$ must be a prime number. The intrinsic returns a Sylow $p$-subgroup of $G$ as a matrix group.
##### `ClassicalSylowConjugation(G, P, S): GrpMat, GrpMat, GrpMat -> GrpMatElt`
The argument $G$ must be a classical group in its natural representation, up to conjugation, with the exception of $GO(2m+1,2^e)$. More precisely, it must be a conjugate of a group returned by one of the intrinsics `GL, SL, Sp, GO, GOPlus, GOMinus, SO, SOPlus, SOMinus, Omega, OmegaPlus, OmegaMinus, GU, SU`. The groups $P$ and $S$ must be Sylow $p$-subgroups of $G$. The intrinsic returns an element $g \in G$ with $P^g = S$.
##### `ClassicalSylowNormaliser(G, P): GrpMat, GrpMat -> GrpMatElt`
In this case $G$ must the full classical group in its natural representation, up to conjugation, with the exception of $GO(2m+1,2^e)$. More precisely, it must be a conjugate of a group returned by one of the intrinsics `GL, Sp, GO, GOPlus, GOMinus, GU`. The subgroup $P$ must be a Sylow $p$-subgroup of $G$. The intrinsic returns the normaliser of $P$ in $G$.
##### `ClassicalSylowToPC(G, P): GrpMat, GrpMat -> GrpPC, UserProgram, Map`
The argument $G$ must be a classical group in its natural representation, up to conjugation, with the exception of $GO(2m+1,2^e)$. More precisely, it must be a conjugate of a group returned by one of the intrinsics `GL, SL, Sp, GO, GOPlus, GOMinus, SO, SOPlus, SOMinus, Omega, OmegaPlus, OmegaMinus, GU, SU`. The group $P$ must be a Sylow $p$-subgroup of $G$. The intrinsic returns a PC group $Q$ isomorphic to $P$, and also an isomorphism from $P$ to $Q$ and an isomorphism from $Q$ to $P$.
##### `Example: Sylow Subgroups of a Symplectic Group (ex-464f7f)`
We construct a Sylow $7$-subgroup $P$ of $G = Sp(28,17^2)$, take a random conjugate $S$ of $P$ and then find a conjugating element $g$ that takes $P$ to $S$.
```magma
> SetSeed(1);
> G := Sp(28,17^2);
> time P := ClassicalSylow(G,7);
Time: 0.080
> S := P^Random(G);
> time g := ClassicalSylowConjugation(G,P,S);
Time: 0.400
```
We next compute the normaliser of $P$ in $G$.
```magma
> time N := ClassicalSylowNormaliser(G,P);
Time: 0.310
> // and a PC presentation of P
> time Pc, PtoPc, PctoP := ClassicalSylowToPC(G,P);
Time: 0.200
> Pc;
GrpPC : Pc of order 2401 = 7^4
PC-Relations:
Pc.1^7 = Id(Pc),
Pc.2^7 = Id(Pc),
Pc.3^7 = Id(Pc),
Pc.4^7 = Id(Pc)
> // We get inverse isomorphisms PtoPc and PctoP
> g := Random(P);
> PctoP(PtoPc(g)) eq g;
true
> x := Random(Pc);
> PtoPc(PctoP(x)) eq x;
true
```
#### Sylow Subgroups of Exceptional Groups
The flags `SuzukiSylow` and `ReeSylow` may be used to produce verbose output.
##### `SuzukiSylow(G, p): GrpMat, RngIntElt -> GrpMat, SeqEnum`
If $G$ has been constructively recognised as a Suzuki group, and if $p$ is a prime number, return a random Sylow $p$-subgroup $S$ of $G$.
Also returns a list of `GrpSLPElt` from the word group of $G$, of the generators of $S$. If $p$ does not divide $\left| G \right|$, then the trivial subgroup is returned.
##### `SuzukiSylowConjugacy(G, R, S, p): GrpMat, GrpMat, GrpMat, RngIntElt -> GrpMatElt, GrpSLPElt`
If $G$ has been constructively recognised as a Suzuki group, if $p$ is a prime number, and if $R$ and $S$ are Sylow $p$-subgroups of $G$, then return an element $g$ of $G$ that conjugates $R$ to $S$. A `GrpSLPElt` from the word group of $G$, that evaluates to $g$, is also returned.
##### `Example: Sylow Subgroups of a Large Suzuki Group (ex-c86d0c)`
We demonstrate finding a conjugating element for Sylow subgroup in an example over a large field.
```magma
> q := 2^121;
> G := Sz(q);
> G ^:= Random(Generic(G));
> G := DerivedGroupMonteCarlo(G);
> NumberOfGenerators(G);
19
```
Non-constructive recognition is now a bit harder.
```magma
> time SuzukiRecognition(G);
true 2658455991569831745807614120560689152
Time: 0.190
> time flag, iso, inv, g2slp, slp2g := RecogniseSz(G);
Time: 22.810
```
However, after this, each call to constructive membership testing is then easy.
```magma
> R := RandomProcess(G);
> g := Random(R);
> time w := Function(g2slp)(g);
Time: 0.060
> // evaluating SLPs always takes some time
> time slp2g(w) eq g;
true
Time: 1.250
```
We now create some Sylow subgroups and find conjugating elements.
```magma
> p := Random([x[1] : x in Factorization(q - 1)]);
> time R := SuzukiSylow(G, p);
Time: 1.370
> time S := SuzukiSylow(G, p);
Time: 1.310
> // that was easy, as is conjugating them
> time g, slp := SuzukiSylowConjugacy(G, R, S, p);
Time: 1.340
> slp2g(slp) eq g;
true
> #R, NumberOfGenerators(R);
23 1
> time R := SuzukiSylow(G, 2);
Time: 164.020
> time S := SuzukiSylow(G, 2);
Time: 171.740
> NumberOfGenerators(R), #R;
121 7067388259113537318333190002971674063309935587502475832486424805170479104
> time g, slp := SuzukiSylowConjugacy(G, R, S, 2);
Time: 1.650
```
Creating the Sylow $2$-subgroup is hard since they have so many generators. One the other hand, finding a conjugating element is relatively easy.
##### `ReeSylow(G, p): GrpMat, RngIntElt -> GrpMat, SeqEnum`
If $G$ has been constructively recognised as a Ree group, and if $p$ is a prime number, return a random Sylow $p$-subgroup $S$ of $G$.
Also returns a list of `GrpSLPElt` from the word group of $G$, of the generators of $S$. If $p$ does not divide $\left| G \right|$, then the trivial subgroup is returned.
##### `ReeSylowConjugacy(G, R, S, p): GrpMat, GrpMat, GrpMat, RngIntElt -> GrpMatElt, GrpSLPElt`
If $G$ has been constructively recognised as ${\rm Ree}(q)$, if $p$ is a prime number, and if $R$ and $S$ are Sylow $p$-subgroups of $G$, then return an element $g$ of $G$ that conjugates $R$ to $S$, and a `GrpSLPElt` from the word group of $G$, that evaluates to $g$, is also returned.
Currently, this is not implemented for odd $p$ that divide $q^3 + 1$.
##### `LargeReeSylow(G, p): GrpMat, RngIntElt -> GrpMat, SeqEnum`
If $G$ has been constructively recognised as a Large Ree group, and if $p$ is a prime number, return a random Sylow $p$-subgroup $S$ of $G$.
Also returns a list of `GrpSLPElt` from the word group of $G$, of the generators of $S$. If $p$ does not divide $\left| G \right|$, then the trivial subgroup is returned.
Currently, this is not implemented for $p$ that divide $q + 1$.
##### `Example: Sylow Subgroups of a Ree Group (ex-026da0)`
Starting with the Ree group over the field ${\bf F}_{3^31}$, we construct Sylow $p$-subgroups for different primes $p$.
```magma
> m := 7;
> F := GF(3, 2 * m + 1);
> q := #F;
> q;
14348907
> G := ReeGroup(F);
> G ^:= Random(Generic(G));
> G := DerivedGroupMonteCarlo(G);
> NumberOfGenerators(G);
19
> ReeRecognition(G);
true 14348907
> flag, iso, inv, g2slp, slp2g := RecogniseRee(G);
> R := RandomProcess(G);
> g := Random(R);
> w := Function(g2slp)(g);
> slp2g(w) eq g;
true
```
We first create two Sylow $p$-subgroups of prime order and find a conjugating element. Note that $4561$ divides the order of $G$ exactly once and also divides $q - 1$.
```magma
> p := 4561;
> R := ReeSylow(G, p);
> S := ReeSylow(G, p);
> g, slp := ReeSylowConjugacy(G, R, S, p);
```
Thus $R^g = S$. In this case we also automatically get an SLP for the conjugating element.
```magma
> slp2g(slp) eq g;
true
> #R, NumberOfGenerators(R);
4561 1
```
Sylow $3$-subgroups are harder: they have order $3^{45}$ and hence a considerable number of generators.
```magma
> time R := ReeSylow(G, 3);
Time: 3.730
> S := ReeSylow(G, 3);
> NumberOfGenerators(R), #R;
15 2954312706550833698643
> time g, slp := ReeSylowConjugacy(G, R, S, 3);
Time: 0.300
```
#### Conjugacy of Subgroups of the Classical Groups
##### `IsGLConjugate(H, K): GrpMat, GrpMat -> BoolElt, GrpMatElt | Unass`
Given $H$ and $K$, both subgroups of the same general linear group $G = GL(n, q)$, return the value `true` if $H$ and $K$ are conjugate in $G$. The function returns a second value in the event that the subgroups are conjugate: an element $z$ which conjugates $H$ into $K$. The algorithm is described in Roney-Dougal [[RD04](https://docs.magma-maths.org/references.md#cite-isglconjugate)].
#### Conjugacy of Elements of the Exceptional Groups
The flags `SuzukiElements` and `ReeElements` may be used to produce verbose output.
##### `SzConjugacyClasses(G): GrpMat -> SeqEnum`
If $G$ has been constructively recognised as a Suzuki group, return a list of conjugacy classes, using the same format as the `ConjugacyClasses` intrinsic.
##### `SzClassRepresentative(G, g): GrpMat, GrpMatElt -> GrpMatElt, GrpMatElt`
If $G$ has been constructively recognised as a Suzuki group, and $g$ is an element of $G$, return the conjugacy class representative $h$ of $g$, such that $h$ is in the list returned by `SzConjugacyClasses`. Also returns $c$ in $G$ such that $g^c = h$.
##### `SzIsConjugate(G, g, h): GrpMat, GrpMatElt, GrpMatElt -> BoolElt, GrpMatElt`
If $G$ has been constructively recognised as a Suzuki group, and $g$ and $h$ are elements of $G$, determine if $g$ is conjugate to $h$. If so, return `true` and an element $c$ such that $g^c = h$, otherwise return `false`.
##### `SzClassMap(G): GrpMat -> Map`
If $G$ has been constructively recognised as a Suzuki group, return its class map, as in the `ClassMap` intrinsic.
##### `ReeConjugacyClasses(G): GrpMat -> SeqEnum`
If $G$ has been constructively recognised as a Ree group, return a list of conjugacy classes, using the same format as the `ConjugacyClasses` intrinsic.
#### Irreducible Subgroups of the General Linear Group
##### `IrreducibleSubgroups(n, q): RngIntElt, RngIntElt -> SeqEnum`
```magma
Soluble : BoolElt Default: true
Insoluble: BoolElt Default: true
```
Return the list of conjugacy classes of irreducible subgroups of $GL(n, q)$ where $n \in \{2, 3\}$ and $q$ is a prime power. The list is complete for characteristic *at least* 5. The insoluble groups of degree 3 were listed by Hurley [[Hur13](https://docs.magma-maths.org/references.md#cite-hurley-phd)]; the remainder by Flannery and O’Brien [[FO05](https://docs.magma-maths.org/references.md#cite-flannery-obrien)]. Respective implementations were developed by Hurley and O’Brien.
If either `Soluble` or `Insoluble` is `false`, then the corresponding groups are omitted; default for both is `true`.
##### `Example: Counting Irreducible Matrix Groups (ex-4bbc80)`
```magma
> L := IrreducibleSubgroups(2, 19^5);
> #[x : x in L | IsAbelian (x)];
552
> L := IrreducibleSubgroups(3, 97^2: Insoluble := false);
> #L;
10620
> L[7];
MatrixGroup(3, GF(97^2))
Generators:
[$.1^2314 $.1^942 $.1^2314]
[$.1^2345 $.1^942 $.1^2314]
[$.1^2345 $.1^617 $.1^2314]
> L := IrreducibleSubgroups(3, 11: Soluble := false);
> #L;
22
```
### 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 [[OW05](https://docs.magma-maths.org/references.md#cite-obrien-wilson)].
#### `StandardGenerators(G, str : parameters): Grp, MonStgElt -> BoolElt, SeqEnum, SeqEnum`
```magma
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`
```magma
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`
```magma
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`
```magma
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`
```magma
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`
```magma
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`
```magma
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: Atlas Data for the Janko Group J1 (ex-328794)`
The machinery is illustrated in the case of the sporadic Janko group $J_1$.
```magma
> 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 |
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
>
```
### Automorphism Groups of Finite Simple Groups
#### `AutomorphismGroupSimpleGroup(type, d, q): MonStgElt, RngIntElt, RngIntElt -> GrpPerm`
#### `AutomorphismGroupSimpleGroup(type, q): MonStgElt, RngIntElt -> GrpPerm`
#### `AutomorphismGroupSimpleGroup(name): MonStgElt -> GrpPerm`
#### `AutomorphismGroupSimpleGroup(triple): Tup -> GrpPerm`
Compute and return a permutation group isomorphic to the full automorphism group of the finite simple group specified by the input parameters.
The first form is for classical groups. `type` can be “L”, “U”, “S”, “O” (for odd dimensions), “O+”, or “O-”, `d` is the dimension, and `q` is the order of the field of definition.
The second form is for alternating or cyclic groups, or exceptional groups of Lie type. `type` can be “A” (for alternating), “C” (for cyclic), “G2”, “Sz” (“Suz”), “2B2” (“TB2”), “Ree” (“R”), “2G2” (“TG2”), “3D4” (“TD4”), “F4”, “E6”, or “2F4” (“TF4”). The types in brackets are alternatives. For the missing types “2E6”, “E7”, and “E8”, there are no permutation representations of sufficiently small degree. The second input parameter `q` is the order of the field of definitions except for types “A” or “C”, when it is the degree.
The third form is for sporadic groups. `type` can be “M11”, “M12”, “M22”, “M23”, “M24”, “J1”, “HS”, “J2”, “HJ”, “McL”, “Suz”, “J3”, “Co1”, “Co2”, “Co3”, “He”, “Fi22” (“F22”), “Fi23” (“F23”), “Fi24” (“F24”),”Ru”, “ON”, or “HN”.
In the fourth form, the input is the triple of integers $$, which is used by Magma to specify a finite simple group. Such a triple is returned as the second return value of `IsSimpleOrder` for example.
## Databases of Groups
- [Introduction](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/introduction.md)
- [Database of Simple Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/simgps-database.md)
- [`SimpleGroup(N): RngIntElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/simgps-database.md#function-simplegroup-rngintelt)
- [`SimpleGroup(S): MonStgElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/simgps-database.md#function-simplegroup-monstgelt)
- [`SimpleGroup(T): Tup → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/simgps-database.md#function-simplegroup-tup)
- [`SimpleGroupOfOrder(M): RngIntElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/simgps-database.md#function-simplegroupoforder-rngintelt)
- [`SimpleGroup(F): RngIntEltFac → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/simgps-database.md#function-simplegroup-rnginteltfac)
- [`NumberOfSimpleGroups() → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/simgps-database.md#function-numberofsimplegroups)
- [`SimpleGroupName(N): RngIntElt → MonStgElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/simgps-database.md#function-simplegroupname-rngintelt)
- [`SimpleGroupNameToNumber(S): MonStgElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/simgps-database.md#function-simplegroupnametonumber-monstgelt)
- [`SimpleGroupIDToNumber(T): Tup → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/simgps-database.md#function-simplegroupidtonumber-tup)
- [`SimpleGroupID(N): RngIntElt → Tup`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/simgps-database.md#function-simplegroupid-rngintelt)
- [Database of Small Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md)
- [Basic Small Group Functions](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#basic-small-group-functions)
- [`SmallGroupDatabase() → DB`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-grpdata-smallgroupdatabase)
- [`OpenSmallGroupDatabase() → DB`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-opensmallgroupdatabase)
- [`delete D: DB`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#operation-grpdata-delete)
- [`SmallGroupDatabaseLimit() → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroupdatabaselimit)
- [`SmallGroupDatabaseLimit(D): DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroupdatabaselimit-db)
- [`IsInSmallGroupDatabase(o): RngIntElt → BoolElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-grpdata-isinsmallgroupdatabase)
- [`IsInSmallGroupDatabase(D, o): DB, RngIntElt → BoolElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-isinsmallgroupdatabase-db-rngintelt)
- [`NumberOfSmallGroups(o): RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-grpdata-numberofsmallgroups)
- [`NumberOfSmallGroups(D, o): DB, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-numberofsmallgroups-db-rngintelt)
- [`SmallGroup(o, n): RngIntElt, RngIntElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-grpdata-smallgroup)
- [`SmallGroup(D, o, n): DB, RngIntElt, RngIntElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroup-db-rngintelt-rngintelt)
- [`Group(D, o, n): DB, RngIntElt, RngIntElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-group-db-rngintelt-rngintelt)
- [`SmallGroup(o: parameters): RngIntElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroup-rngintelt)
- [`SmallGroup(D, o: parameters): DB, RngIntElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroup-db-rngintelt)
- [`SmallGroup(o, f: parameters): RngIntElt, Program → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroup-rngintelt-program)
- [`SmallGroup(D, o, f: parameters): RngIntElt, Program → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroup-rngintelt-program-2)
- [`IsSoluble(D, o, n): DB, RngIntElt, RngIntElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-issoluble-db-rngintelt-rngintelt)
- [`IsSolvable(D, o, n): DB, RngIntElt, RngIntElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-issolvable-db-rngintelt-rngintelt)
- [`SmallGroupIsSoluble(o, n): RngIntElt, RngIntElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroupissoluble-rngintelt-rngintelt)
- [`SmallGroupIsSoluble(D, o, n): DB, RngIntElt, RngIntElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroupissoluble-db-rngintelt-rngintelt)
- [`SmallGroupIsSolvable(o, n): RngIntElt, RngIntElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroupissolvable-rngintelt-rngintelt)
- [`SmallGroupIsSolvable(D, o, n): DB, RngIntElt, RngIntElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroupissolvable-db-rngintelt-rngintelt)
- [`SmallGroupIsInsoluble(o, n): RngIntElt, RngIntElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroupisinsoluble-rngintelt-rngintelt)
- [`SmallGroupIsInsoluble(D, o, n): DB, RngIntElt, RngIntElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroupisinsoluble-db-rngintelt-rngintelt)
- [`SmallGroupIsInsolvable(o, n): RngIntElt, RngIntElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroupisinsolvable-rngintelt-rngintelt)
- [`SmallGroupIsInsolvable(D, o, n): DB, RngIntElt, RngIntElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroupisinsolvable-db-rngintelt-rngintelt)
- [`SmallGroup(o, f: parameters): RngIntElt, Program → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroup-rngintelt-program-3)
- [`SmallGroup(S, f: parameters): [RngIntElt], Program → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroup-rngintelt-program-4)
- [`SmallGroup(D, o, f: parameters): DB, RngIntElt, Program → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroup-db-rngintelt-program)
- [`SmallGroup(D, S, f: parameters): DB, [RngIntElt], Program → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroup-db-rngintelt-program-2)
- [`SmallGroups(o: parameters): RngIntElt → [* Grp *]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroups-rngintelt)
- [`SmallGroups(D, o: parameters): DB, RngIntElt → [* Grp *]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroups-db-rngintelt)
- [`SmallGroups(S: parameters): [RngIntElt] → [* Grp *]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroups-rngintelt-2)
- [`SmallGroups(D, S: parameters): DB, [RngIntElt] → [* Grp *]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroups-db-rngintelt-2)
- [`SmallGroups(o, f: parameters): RngIntElt, Program → [* Grp *]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroups-rngintelt-program)
- [`SmallGroups(D, o, f: parameters): DB, RngIntElt, Program → [* Grp *]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroups-db-rngintelt-program)
- [`SmallGroups(S, f: parameters): [RngIntElt], Program → [* Grp *]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroups-rngintelt-program-2)
- [`SmallGroups(D, S, f: parameters): DB, [RngIntElt], Program → [* Grp *]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroups-db-rngintelt-program-2)
- [Example: Non-Abelian Groups of Order 27](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#example-ex-dd4fa3)
- [Processes](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#processes)
- [`SmallGroupProcess(o: parameters): RngIntElt → Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroupprocess-rngintelt)
- [`SmallGroupProcess(S: parameters): [RngIntElt] → Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroupprocess-rngintelt-2)
- [`SmallGroupProcess(o, f: parameters): RngIntElt, Program → Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroupprocess-rngintelt-program)
- [`SmallGroupProcess(S, f: parameters): [RngIntElt], Program → Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroupprocess-rngintelt-program-2)
- [`IsEmpty(p): Process → BoolElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-isempty-process)
- [`Current(p): Process → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-current-process)
- [`CurrentLabel(p): Process → RngIntElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-currentlabel-process)
- [`Advance(~p): Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#procedure-advance-process-ref)
- [Example: Nilpotency Classes of Groups of Order 128](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#example-ex-091a11)
- [Small Group Identification](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#small-group-identification)
- [`IdentifyGroup(G): Grp → Tup`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-grpdata-identifygroup)
- [`IdentifyGroup(D, G): DB, Grp → Tup`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-identifygroup-db-grp)
- [`CanIdentifyGroup(o): RngIntElt → BoolElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-grpdata-canidentifygroup)
- [`CanIdentifyGroup(D, o): DB, RngIntElt → BoolElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-canidentifygroup-db-rngintelt)
- [`IdentifyGroupBySearch(G): Grp → Tup`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-grpdata-identifygroupbysearch)
- [Example: Identifying a Small Group](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#example-ex-718e51)
- [Example: Identifying a Group by Search](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#example-ex-10803c)
- [Example: Identifying a Finitely Presented Group](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#example-ex-0670f9)
- [Accessing Internal Data](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#accessing-internal-data)
- [`Data(D, o, n): DB, RngIntElt, RngIntElt → List`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-data-db-rngintelt-rngintelt)
- [`SmallGroupEncoding(G): GrpPC → RngIntElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroupencoding-grppc)
- [`SmallGroupDecoding(c, o): RngIntElt, RngIntElt → GrpPC`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-smallgroupdecoding-rngintelt-rngintelt)
- [Example: Internal Data of the Small Groups Database](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#example-ex-c39570)
- [Groups with Order Divisible by Only 4 Primes](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#groups-with-order-divisible-by-only-4-primes)
- [`Group4P(o, i): RngIntElt, RngIntElt → Grp`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-group4p-rngintelt-rngintelt)
- [`Groups4P(o): RngIntElt → List`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-groups4p-rngintelt)
- [`NumberOfGroups4P(o): RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-numberofgroups4p-rngintelt)
- [`IdentifyGroup4P(G): GrpPC → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-identifygroup4p-grppc)
- [`IdentifyGroup4P(G): GrpPerm → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-identifygroup4p-grpperm)
- [`IdentifyGroup4P(G): GrpMat → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-identifygroup4p-grpmat)
- [The $p$-groups of Order Dividing $p^7$](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/p-groups.md)
- [`SearchPGroups(p, n: parameters): RngIntElt, RngIntElt → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/p-groups.md#function-searchpgroups-rngintelt-rngintelt)
- [`CountPGroups(p, n: parameters): RngIntElt, RngIntElt → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/p-groups.md#function-countpgroups-rngintelt-rngintelt)
- [Example: Searching Groups of Order 19^7](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/p-groups.md#example-ex-1addd3)
- [Metacyclic $p$-groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/search.md)
- [`MetacyclicPGroups(p, n: parameters): RngIntElt, RngIntElt → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/search.md#function-metacyclicpgroups-rngintelt-rngintelt)
- [`IsMetacyclicPGroup(P): Grp → BoolElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/search.md#function-ismetacyclicpgroup-grp)
- [`InvariantsMetacyclicPGroup(P): Grp → Tup`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/search.md#function-invariantsmetacyclicpgroup-grp)
- [`StandardMetacyclicPGroup(P): Grp → GrpPC`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/search.md#function-standardmetacyclicpgroup-grp)
- [`NumberOfMetacyclicPGroups(p, n): RngIntElt, RngIntElt → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/search.md#function-numberofmetacyclicpgroups-rngintelt-rngintelt)
- [`HasAllPQuotientsMetacyclic(G): GrpFP → BoolElt, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/search.md#function-hasallpquotientsmetacyclic-grpfp)
- [`HasAllPQuotientsMetacyclic(G, p): GrpFP → BoolElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/search.md#function-hasallpquotientsmetacyclic-grpfp-2)
- [Example: Metacyclic 3-Groups of Order 729](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/search.md#example-ex-0140ea)
- [Database of Perfect Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md)
- [Specifying an Entry of the Database](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#specifying-an-entry-of-the-database)
- [Creating the Database](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#creating-the-database)
- [`PerfectGroupDatabase() → DB`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-perfectgroupdatabase)
- [Accessing the Database](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#accessing-the-database)
- [`Group(D, i): DB, RngIntElt → GrpFP, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-group-db-rngintelt)
- [`Group(D, o, i): DB, RngIntElt, RngIntElt → GrpFP, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-group-db-rngintelt-rngintelt-2)
- [`Group(D, Q): DB, MonStgElt → GrpFP, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-group-db-monstgelt)
- [`Group(D, Q, p, r, n: parameters): DB, MonStgElt, RngIntElt, RngIntElt, RngIntElt, RngIntElt → GrpFP, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-group-db-monstgelt-rngintelt-rngintelt-rngintelt-rngintelt)
- [`IdentificationNumber(D, i): DB, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-identificationnumber-db-rngintelt)
- [`IdentificationNumber(D, o, i): DB, RngIntElt, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-identificationnumber-db-rngintelt-rngintelt)
- [`IdentificationNumber(D, Q): DB, MonStgElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-identificationnumber-db-monstgelt)
- [`IdentificationNumber(D, Q, p, r, n: parameters): DB, MonStgElt, RngIntElt, RngIntElt, RngIntElt, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-identificationnumber-db-monstgelt-rngintelt-rngintelt-rngintelt-rngintelt)
- [`NumberOfRepresentations(D, i): DB, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-numberofrepresentations-db-rngintelt)
- [`NumberOfRepresentations(D, o, i): DB, RngIntElt, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-numberofrepresentations-db-rngintelt-rngintelt)
- [`NumberOfRepresentations(D, Q): DB, MonStgElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-numberofrepresentations-db-monstgelt)
- [`NumberOfRepresentations(D, Q, p, r, n: parameters): DB, MonStgElt, RngIntElt, RngIntElt, RngIntElt, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-numberofrepresentations-db-monstgelt-rngintelt-rngintelt-rngintelt-rngintelt)
- [`PermutationRepresentation(D, i: parameters): DB, RngIntElt → Hom(Grp), GrpFP, GrpPerm`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-permutationrepresentation-db-rngintelt)
- [`PermutationRepresentation(D, o, i: parameters): DB, RngIntElt, RngIntElt → Hom(Grp), GrpFP, GrpPerm`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-permutationrepresentation-db-rngintelt-rngintelt)
- [`PermutationRepresentation(D, Q: parameters): DB, MonStgElt → Hom(Grp), GrpFP, GrpPerm`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-permutationrepresentation-db-monstgelt)
- [`PermutationRepresentation(D, Q, p, r, n: parameters): DB, MonStgElt, RngIntElt, RngIntElt, RngIntElt, RngIntElt → Hom(Grp), GrpFP, GrpPerm`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-permutationrepresentation-db-monstgelt-rngintelt-rngintelt-rngintelt-rngintelt)
- [`PermutationGroup(D, i: parameters): DB, RngIntElt → GrpPerm`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-permutationgroup-db-rngintelt)
- [`PermutationGroup(D, o, i: parameters): DB, RngIntElt, RngIntElt → GrpPerm`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-permutationgroup-db-rngintelt-rngintelt)
- [`PermutationGroup(D, Q: parameters): DB, MonStgElt → GrpPerm`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-permutationgroup-db-monstgelt)
- [`PermutationGroup(D, Q, p, r, n: parameters): DB, MonStgElt, RngIntElt, RngIntElt, RngIntElt, RngIntElt → GrpPerm`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-permutationgroup-db-monstgelt-rngintelt-rngintelt-rngintelt-rngintelt)
- [Finding Legal Keys](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#finding-legal-keys)
- [`# D: DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#operation-operation-db-rngintelt)
- [`NumberOfGroups(D): DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-numberofgroups-db)
- [`NumberOfGroups(D, o): DB, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-numberofgroups-db-rngintelt)
- [`TopQuotients(D): DB → SetIndx`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-topquotients-db)
- [`ExtensionPrimes(D, Q): DB, MonStgElt → SetEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-extensionprimes-db-monstgelt)
- [`ExtensionExponents(D, Q, p): DB, MonStgElt, RngIntElt → SetEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-extensionexponents-db-monstgelt-rngintelt)
- [`ExtensionNumbers(D, Q, p, r): DB, MonStgElt, RngIntElt, RngIntElt → SetEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-extensionnumbers-db-monstgelt-rngintelt-rngintelt)
- [`ExtensionClasses(D, Q): DB, MonStgElt → SetEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#function-extensionclasses-db-monstgelt)
- [Example: Finding an Extension of L(3, 4)](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/pfgps.md#example-ex-aa434a)
- [Database of Almost-Simple Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/sgdb.md)
- [The Record Fields](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/sgdb.md#the-record-fields)
- [Creating the Database](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/sgdb.md#creating-the-database)
- [`AlmostSimpleGroupDatabase() → DB`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/sgdb.md#function-almostsimplegroupdatabase)
- [Accessing the Database](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/sgdb.md#accessing-the-database)
- [`# D: DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/sgdb.md#operation-operation-db-rngintelt)
- [`GroupData(D, i): DB, RngIntElt → Rec`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/sgdb.md#function-groupdata-db-rngintelt)
- [`GroupData(D, o1, o2, k): DB, RngIntElt, RngIntElt, RngIntElt → Rec`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/sgdb.md#function-groupdata-db-rngintelt-rngintelt-rngintelt)
- [`ExistsGroupData(D, o1, o2): DB, RngIntElt, RngIntElt → BoolElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/sgdb.md#function-existsgroupdata-db-rngintelt-rngintelt)
- [`ExistsGroupData(D, o1, o2, i): DB, RngIntElt, RngIntElt, RngIntElt → BoolElt, Rec`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/sgdb.md#function-existsgroupdata-db-rngintelt-rngintelt-rngintelt)
- [`NumberOfGroups(D, o1, o2): DB, RngIntElt, RngIntElt → RngIntElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/sgdb.md#function-numberofgroups-db-rngintelt-rngintelt)
- [`IdentifyAlmostSimpleGroup(G): GrpPerm → Map, GrpPerm`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/sgdb.md#function-identifyalmostsimplegroup-grpperm)
- [`IdentifyAlmostSimpleGroup(G): GrpMat → Map, GrpPerm`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/sgdb.md#function-identifyalmostsimplegroup-grpmat)
- [Example: Querying an Almost Simple Group of Order 720](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/sgdb.md#example-ex-6b4019)
- [Database of Transitive Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md)
- [Accessing the Databases](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#accessing-the-databases)
- [`TransitiveGroupDatabaseLimit() → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-transitivegroupdatabaselimit)
- [`NumberOfTransitiveGroups(d): RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-numberoftransitivegroups-rngintelt)
- [`TransitiveGroup(d, n): RngIntElt, RngIntElt → GrpPerm, MonStgElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-transitivegroup-rngintelt-rngintelt)
- [`TransitiveGroupDescription(d, n): RngIntElt, RngIntElt → MonStgElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-transitivegroupdescription-rngintelt-rngintelt)
- [`TransitiveGroupDescription(G): GrpPerm → MonStgElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-transitivegroupdescription-grpperm)
- [`TransitiveGroup(d): RngIntElt → GrpPerm, MonStgElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-transitivegroup-rngintelt)
- [`TransitiveGroup(d, f): RngIntElt, Program → GrpPerm, MonStgElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-transitivegroup-rngintelt-program)
- [`TransitiveGroup(S, f): [RngIntElt], Program → GrpPerm, MonStgElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-transitivegroup-rngintelt-program-2)
- [`TransitiveGroups(d: parameters): RngIntElt → [GrpPerm]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-transitivegroups-rngintelt)
- [`TransitiveGroups(S: parameters): [RngIntElt] → [GrpPerm]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-transitivegroups-rngintelt-2)
- [`TransitiveGroups(d, f): RngIntElt, Program → [GrpPerm]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-transitivegroups-rngintelt-program)
- [`TransitiveGroups(S, f): [RngIntElt], Program → [GrpPerm]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-transitivegroups-rngintelt-program-2)
- [Example: Transitive Groups of Degree 8](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#example-ex-95bf5a)
- [Example: Isomorphic Non-Conjugate Transitive Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#example-ex-974219)
- [Processes](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#processes)
- [`TransitiveGroupProcess(d): RngIntElt → Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-transitivegroupprocess-rngintelt)
- [`TransitiveGroupProcess(S): [RngIntElt] → Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-transitivegroupprocess-rngintelt-2)
- [`TransitiveGroupProcess(d, f): RngIntElt, Program → Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-transitivegroupprocess-rngintelt-program)
- [`TransitiveGroupProcess(S, f): [RngIntElt], Program → Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-transitivegroupprocess-rngintelt-program-2)
- [`IsEmpty(p): Process → BoolElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-isempty-process-2)
- [`Current(p): Process → GrpPerm, MonStgElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-current-process-2)
- [`CurrentLabel(p): Process → RngIntElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-currentlabel-process-2)
- [`Advance(~p): Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#procedure-advance-process-ref-2)
- [Example: Processing Transitive Groups of Degree 5](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#example-ex-851721)
- [Transitive Group Identification](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#transitive-group-identification)
- [`TransitiveGroupIdentification(G): GrpPerm → RngIntElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#function-transitivegroupidentification-grpperm)
- [Example: Identifying a Transitive Group](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/transgp-data.md#example-ex-026a1e)
- [Database of Primitive Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md)
- [Accessing the Databases](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#accessing-the-databases)
- [`PrimitiveGroupDatabaseLimit() → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroupdatabaselimit)
- [`NumberOfPrimitiveGroups(d): RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-numberofprimitivegroups-rngintelt)
- [`NumberOfPrimitiveSolubleGroups(d): RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-numberofprimitivesolublegroups-rngintelt)
- [`NumberOfPrimitiveAffineGroups(d): RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-numberofprimitiveaffinegroups-rngintelt)
- [`NumberOfPrimitiveDiagonalGroups(d): RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-numberofprimitivediagonalgroups-rngintelt)
- [`NumberOfPrimitiveProductGroups(d): RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-numberofprimitiveproductgroups-rngintelt)
- [`NumberOfPrimitiveAlmostSimpleGroups(d): RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-numberofprimitivealmostsimplegroups-rngintelt)
- [`PrimitiveGroup(d, n): RngIntElt, RngIntElt → GrpPerm, MonStgElt, MonStgElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroup-rngintelt-rngintelt)
- [`PrimitiveGroupDescription(d, n): RngIntElt, RngIntElt → MonStgElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroupdescription-rngintelt-rngintelt)
- [`PrimitiveGroup(d): RngIntElt → GrpPerm, MonStgElt, MonStgElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroup-rngintelt)
- [`PrimitiveGroup(d, f): RngIntElt, Program → GrpPerm, MonStgElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroup-rngintelt-program)
- [`PrimitiveGroup(S, f): [RngIntElt], Program → GrpPerm, MonStgElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroup-rngintelt-program-2)
- [`PrimitiveGroups(d: parameters): RngIntElt → [GrpPerm]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroups-rngintelt)
- [`PrimitiveGroups(S: parameters): [RngIntElt] → [GrpPerm]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroups-rngintelt-2)
- [`PrimitiveGroups( : parameters) → [GrpPerm]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroups)
- [`PrimitiveGroups(d, f: parameters): RngIntElt, Program → [GrpPerm]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroups-rngintelt-program)
- [`PrimitiveGroups(S, f): [RngIntElt], Program → [GrpPerm]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroups-rngintelt-program-2)
- [`PrimitiveGroups(f): Program → [GrpPerm]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroups-program)
- [Example: Primitive Groups of Degree 625](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#example-ex-d6ff61)
- [Processes](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#processes)
- [`PrimitiveGroupProcess(d: parameters): RngIntElt → Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroupprocess-rngintelt)
- [`PrimitiveGroupProcess(S: parameters): [RngIntElt] → Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroupprocess-rngintelt-2)
- [`PrimitiveGroupProcess(: parameters) → Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroupprocess)
- [`PrimitiveGroupProcess(d, f: parameters): RngIntElt, Program → Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroupprocess-rngintelt-program)
- [`PrimitiveGroupProcess(S, f: parameters): [RngIntElt], Program → Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroupprocess-rngintelt-program-2)
- [`PrimitiveGroupProcess(f: parameters): Program → Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroupprocess-program)
- [`IsEmpty(p): Process → BoolElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-isempty-process-3)
- [`Current(p): Process → GrpPerm, MonStgElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-current-process-3)
- [`CurrentLabel(p): Process → RngIntElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-currentlabel-process-3)
- [`Advance(~p): Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#procedure-advance-process-ref-3)
- [Example: Processing Primitive Groups of Degree 60](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#example-ex-932032)
- [Primitive Group Identification](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#primitive-group-identification)
- [`PrimitiveGroupIdentification(G): GrpPerm → RngIntElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#function-primitivegroupidentification-grpperm)
- [Example: Identifying a Primitive Group](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/primgp-data.md#example-ex-2ae1d1)
- [Database of Rational Maximal Finite Matrix Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ratgps.md)
- [`RationalMatrixGroupDatabase() → DB`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ratgps.md#function-rationalmatrixgroupdatabase)
- [`LargestDimension(D): DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ratgps.md#function-largestdimension-db)
- [`# D: DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ratgps.md#operation-operation-db-rngintelt)
- [`NumberOfGroups(D): DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ratgps.md#function-numberofgroups-db-2)
- [`NumberOfLattices(D): DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ratgps.md#function-numberoflattices-db)
- [`NumberOfGroups(D, d): DB, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ratgps.md#function-numberofgroups-db-rngintelt-2)
- [`NumberOfLattices(D, d): DB, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ratgps.md#function-numberoflattices-db-rngintelt)
- [`Group(D, i): DB, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ratgps.md#function-group-db-rngintelt-2)
- [`Lattice(D, i): DB, RngIntElt → Lat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ratgps.md#function-lattice-db-rngintelt)
- [`Group(D, d, i): DB, RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ratgps.md#function-group-db-rngintelt-rngintelt-3)
- [`Lattice(D, d, i): DB, RngIntElt, RngIntElt → Lat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ratgps.md#function-lattice-db-rngintelt-rngintelt)
- [Example: Counting Rational Matrix Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ratgps.md#example-ex-34d380)
- [Database of Integral Maximal Finite Matrix Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/intgps.md)
- [`IntegralMatrixGroupDatabase() → DB`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/intgps.md#function-integralmatrixgroupdatabase)
- [`LargestDimension(D): DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/intgps.md#function-largestdimension-db-2)
- [`# D: DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/intgps.md#operation-operation-db-rngintelt)
- [`NumberOfGroups(D): DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/intgps.md#function-numberofgroups-db-3)
- [`NumberOfLattices(D): DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/intgps.md#function-numberoflattices-db-2)
- [`NumberOfGroups(D, d): DB, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/intgps.md#function-numberofgroups-db-rngintelt-3)
- [`NumberOfLattices(D, d): DB, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/intgps.md#function-numberoflattices-db-rngintelt-2)
- [`Group(D, i): DB, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/intgps.md#function-group-db-rngintelt-3)
- [`Lattice(D, i): DB, RngIntElt → Lat, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/intgps.md#function-lattice-db-rngintelt-2)
- [`Construction(D, i): DB, RngIntElt → MonStgElt, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/intgps.md#function-construction-db-rngintelt)
- [`Group(D, d, i): DB, RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/intgps.md#function-group-db-rngintelt-rngintelt-4)
- [`Lattice(D, d, i): DB, RngIntElt, RngIntElt → Lat, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/intgps.md#function-lattice-db-rngintelt-rngintelt-2)
- [`Construction(D, d, i): DB, RngIntElt, RngIntElt → MonStgElt, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/intgps.md#function-construction-db-rngintelt-rngintelt)
- [Example: Accessing Integral Matrix Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/intgps.md#example-ex-2e0f58)
- [Database of Finite Quaternionic Matrix Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/quatgps.md)
- [`QuaternionicMatrixGroupDatabase() → DB`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/quatgps.md#function-quaternionicmatrixgroupdatabase)
- [`LargestDimension(D): DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/quatgps.md#function-largestdimension-db-3)
- [`# D: DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/quatgps.md#operation-operation-db-rngintelt)
- [`NumberOfGroups(D): DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/quatgps.md#function-numberofgroups-db-4)
- [`NumberOfLattices(D): DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/quatgps.md#function-numberoflattices-db-3)
- [`NumberOfGroups(D, d): DB, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/quatgps.md#function-numberofgroups-db-rngintelt-4)
- [`NumberOfLattices(D, d): DB, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/quatgps.md#function-numberoflattices-db-rngintelt-3)
- [`Group(D, i): DB, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/quatgps.md#function-group-db-rngintelt-4)
- [`Lattice(D, i): DB, RngIntElt → Lat, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/quatgps.md#function-lattice-db-rngintelt-3)
- [`Construction(D, i): DB, RngIntElt → MonStgElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/quatgps.md#function-construction-db-rngintelt-2)
- [`Group(D, d, i): DB, RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/quatgps.md#function-group-db-rngintelt-rngintelt-5)
- [`Lattice(D, d, i): DB, RngIntElt, RngIntElt → Lat, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/quatgps.md#function-lattice-db-rngintelt-rngintelt-3)
- [`Construction(D, d, i): DB, RngIntElt, RngIntElt → MonStgElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/quatgps.md#function-construction-db-rngintelt-rngintelt-2)
- [Example: Quaternionic Matrix Groups of Dimension 36](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/quatgps.md#example-ex-00c791)
- [Database of Finite Symplectic Matrix Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/symplgps.md)
- [`SymplecticMatrixGroupDatabase() → DB`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/symplgps.md#function-symplecticmatrixgroupdatabase)
- [`LargestDimension(D): DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/symplgps.md#function-largestdimension-db-4)
- [`# D: DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/symplgps.md#operation-operation-db-rngintelt)
- [`NumberOfGroups(D): DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/symplgps.md#function-numberofgroups-db-5)
- [`NumberOfLattices(D): DB → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/symplgps.md#function-numberoflattices-db-4)
- [`NumberOfGroups(D, d): DB, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/symplgps.md#function-numberofgroups-db-rngintelt-5)
- [`NumberOfLattices(D, d): DB, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/symplgps.md#function-numberoflattices-db-rngintelt-4)
- [`Group(D, i): DB, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/symplgps.md#function-group-db-rngintelt-5)
- [`Lattice(D, i): DB, RngIntElt → Lat, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/symplgps.md#function-lattice-db-rngintelt-4)
- [`Construction(D, i): DB, RngIntElt → MonStgElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/symplgps.md#function-construction-db-rngintelt-3)
- [`Group(D, d, i): DB, RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/symplgps.md#function-group-db-rngintelt-rngintelt-6)
- [`Lattice(D, d, i): DB, RngIntElt, RngIntElt → Lat, SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/symplgps.md#function-lattice-db-rngintelt-rngintelt-4)
- [`Construction(D, d, i): DB, RngIntElt, RngIntElt → MonStgElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/symplgps.md#function-construction-db-rngintelt-rngintelt-3)
- [Example: Symplectic Matrix Groups of Dimension 16](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/symplgps.md#example-ex-c0dcaf)
- [Database of Irreducible Matrix Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/irrgp-data.md)
- [Accessing the Database](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/irrgp-data.md#accessing-the-database)
- [`NumberOfIrreducibleMatrixGroups(k, p): RngIntElt, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/irrgp-data.md#function-numberofirreduciblematrixgroups-rngintelt-rngintelt)
- [`NumberOfSolubleIrreducibleMatrixGroups(k, p): RngIntElt, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/irrgp-data.md#function-numberofsolubleirreduciblematrixgroups-rngintelt-rngintelt)
- [`IrreducibleMatrixGroup(k, p, n): RngIntElt, RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/irrgp-data.md#function-irreduciblematrixgroup-rngintelt-rngintelt-rngintelt)
- [Example: Irreducible Matrix Groups in GL(4, 5)](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/irrgp-data.md#example-ex-462c7c)
- [Database of Quasisimple Matrix Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/quasisimplematgp-data.md)
- [`QuasisimpleMatrixGroup(N, d, p : parameters): MonStgElt, RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/quasisimplematgp-data.md#function-quasisimplematrixgroup-monstgelt-rngintelt-rngintelt)
- [`QuasisimpleMatrixGroups() → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/quasisimplematgp-data.md#function-quasisimplematrixgroups)
- [Database of Soluble Irreducible Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md)
- [Basic Functions](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#basic-functions)
- [`IsolGroupDatabase() → DB`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-isolgroupdatabase)
- [`IsolGroup(n, p, i): RngIntElt, RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-grpdata-isolgroup)
- [`Group(D, n, p, i): DB, RngIntElt, RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-group-db-rngintelt-rngintelt-rngintelt)
- [`IsolNumberOfDegreeField(n, p): RngIntElt, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-isolnumberofdegreefield-rngintelt-rngintelt)
- [`IsolInfo(n, p, i): RngIntElt, RngIntElt, RngIntElt → MonStgElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-isolinfo-rngintelt-rngintelt-rngintelt)
- [`IsolOrder(n, p, i): RngIntElt, RngIntElt, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-isolorder-rngintelt-rngintelt-rngintelt)
- [`IsolMinBlockSize(n, p, i): RngIntElt, RngIntElt, RngIntElt → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-isolminblocksize-rngintelt-rngintelt-rngintelt)
- [`IsolIsPrimitive(n, p, i): RngIntElt, RngIntElt, RngIntElt → BoolElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-isolisprimitive-rngintelt-rngintelt-rngintelt)
- [`IsolGuardian(n, p, i): RngIntElt, RngIntElt, RngIntElt → GrpMat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-isolguardian-rngintelt-rngintelt-rngintelt)
- [Example: Group of Degree 3 and Its Guardian](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#example-ex-f88165)
- [Searching with Predicates](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#searching-with-predicates)
- [`IsolGroupSatisfying(f): Any → GrpMat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-isolgroupsatisfying-any)
- [`IsolGroupOfDegreeSatisfying(d, f): RngIntElt, Any → GrpMat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-isolgroupofdegreesatisfying-rngintelt-any)
- [`IsolGroupOfDegreeFieldSatisfying(d, p, f): RngIntElt, RngIntElt, Any → GrpMat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-isolgroupofdegreefieldsatisfying-rngintelt-rngintelt-any)
- [`IsolGroupsSatisfying(f): Any → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-isolgroupssatisfying-any)
- [`IsolGroupsOfDegreeSatisfying(d, f): RngIntElt, Any → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-isolgroupsofdegreesatisfying-rngintelt-any)
- [`IsolGroupsOfDegreeFieldSatisfying(d, p, f): RngIntElt, RngIntElt, Any → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-isolgroupsofdegreefieldsatisfying-rngintelt-rngintelt-any)
- [Associated Functions](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#associated-functions)
- [`Getvecs(G): GrpMat → SeqEnum`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-getvecs-grpmat)
- [`Semidir(G, Q): GrpMat, SeqEnum → GrpPerm`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-semidir-grpmat-seqenum)
- [Processes](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#processes)
- [`IsolProcess() → Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-isolprocess)
- [`IsolProcessOfDegree(d): . → Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-isolprocessofdegree)
- [`IsolProcessOfField(p): . → Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-isolprocessoffield)
- [`IsolProcessOfDegreeField(d, p): ., . → Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-isolprocessofdegreefield)
- [`IsEmpty(p): Process → BoolElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-isempty-process-4)
- [`Current(p): Process → GrpMat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-current-process-4)
- [`CurrentLabel(p): Process → RngIntElt, RngIntElt, RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#function-currentlabel-process-4)
- [`Advance(~p): Process`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#procedure-advance-process-ref-4)
- [Example: Processing All Groups of Degree 3](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/isolgps-database.md#example-ex-4ef256)
- [Database of ATLAS Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md)
- [Example: Listing ATLAS Group Names](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#example-ex-7bb063)
- [Accessing the Database](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#accessing-the-database)
- [`ATLASGroupNames() → SetIndx[MonStgElt]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#function-atlasgroupnames)
- [`ATLASGroup(N): MonStgElt → GrpAtlas`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#function-atlasgroup)
- [Accessing the ATLAS Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#accessing-the-atlas-groups)
- [`Order(A): GrpAtlas → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#function-order-grpatlas)
- [`# G: GrpAtlas → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#operation-operation-grpatlas-rngintelt)
- [`Multiplier(A): GrpAtlas → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#function-multiplier-grpatlas)
- [`MatRepKeys(A): GrpAtlas → SeqEnum[DBAtlasKeyMatRep]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#function-matrepkeys-grpatlas)
- [`MatRepDegrees(A): GrpAtlas → SetEnum[RngIntElt]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#function-matrepdegrees-grpatlas)
- [`Degree(K): DBAtlasKeyMatRep → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#function-degree-dbatlaskeymatrep)
- [`MatRepFieldSizes(A): GrpAtlas → SetEnum[RngIntElt]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#function-matrepfieldsizes-grpatlas)
- [`MatRepCharacteristics(A): GrpAtlas → SetEnum[RngIntElt]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#function-matrepcharacteristics-grpatlas)
- [`Field(K): DBAtlasKeyMatRep → FldFin`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#function-field-dbatlaskeymatrep)
- [`PermRepKeys(A): GrpAtlas → SeqEnum[DBAtlasKeyPermRep]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#function-permrepkeys-grpatlas)
- [`PermRepDegrees(A): GrpAtlas → SetEnum[RngIntElt]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#function-permrepdegrees-grpatlas)
- [`Degree(K): DBAtlasKeyPermRep → RngIntElt`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#function-degree-dbatlaskeypermrep)
- [Representations of the ATLAS Groups](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#representations-of-the-atlas-groups)
- [`MatrixGroup(K): DBAtlasKeyMatRep → GrpMat`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#function-matrixgroup-dbatlaskeymatrep)
- [`MatRep(K): DBAtlasKeyMatRep → SeqEnum[GrpMatElt]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#function-matrep-dbatlaskeymatrep)
- [`PermutationGroup(K): DBAtlasKeyPermRep → GrpPerm`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#function-permutationgroup-dbatlaskeypermrep)
- [`PermRep(K): DBAtlasKeyPermRep → SeqEnum[GrpPermElt]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#function-permrep-dbatlaskeypermrep)
- [Example: Representations of 2.J2.2](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/ATLAS-database.md#example-ex-d60e34)
- [Fundamental Groups of 3-Manifolds](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/3-manifolds-database.md)
- [Basic Functions](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/3-manifolds-database.md#basic-functions)
- [`ManifoldDatabase() → DB`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/3-manifolds-database.md#function-manifolddatabase)
- [`Manifold(D, i): DB, RngIntElt → Rec`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/3-manifolds-database.md#function-manifold-db-rngintelt)
- [`Manifold(D, name): DB, MonStgElt → Rec`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/3-manifolds-database.md#function-manifold-db-monstgelt)
- [Accessing the Data](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/3-manifolds-database.md#accessing-the-data)
- [Example: Records from the 3-Manifolds Database](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/3-manifolds-database.md#example-ex-f8e221)
- [Automatic Groups of 3-Manifolds](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/automatic-group-database.md)
- [`AutomaticGroup(i): RngIntElt → GrpAtc`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/automatic-group-database.md#function-automaticgroup-rngintelt)
- [`AutomaticGroup(name): MonStgElt → GrpAtc`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/automatic-group-database.md#function-automaticgroup-monstgelt)
- [`AutomaticGroup(r): Rec → GrpAtc`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/automatic-group-database.md#function-automaticgroup-rec)
- [`AutomaticGroupIndices() → [RngIntElt]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/automatic-group-database.md#function-automaticgroupindices)
- [`AutomaticGroupNames() → [MonStgElt]`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/automatic-group-database.md#function-automaticgroupnames)
- [Bibliography](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/bibliography.md)
### Introduction
This chapter describes the use of the various databases of groups that form part of Magma. The available databases are as follows:
*Simple Groups*: This database contains all the simple groups of order less than $10^{20}$. While Magma contains tools that allow the user to construct any finite simple group the purpose of this facility is to make it easier to access a simple group and to run through the simple groups in order of increasing group order.
*Small Groups*: This database is constructed by Hans Ulrich Besche, Heiko Dietrich, Bettina Eick, Eamonn O’Brien, and Eileen Pan [[BE99a](https://docs.magma-maths.org/references.md#cite-besche-eick-constr), [BE99b](https://docs.magma-maths.org/references.md#cite-besche-eick-1000), [BE01](https://docs.magma-maths.org/references.md#cite-besche-eick-order-qnp), [BEO01](https://docs.magma-maths.org/references.md#cite-besche-eick-obrien-order-2000), [DE05](https://docs.magma-maths.org/references.md#cite-dietrich-eick), [DEP22](https://docs.magma-maths.org/references.md#cite-dep4primes), [MNVL04](https://docs.magma-maths.org/references.md#cite-newman-ob-vl-04), [OBr90](https://docs.magma-maths.org/references.md#cite-obrien-pgroup), [OBr91](https://docs.magma-maths.org/references.md#cite-obrien-groups-256), [OVL05](https://docs.magma-maths.org/references.md#cite-ob-vl-05)], and contains the following groups:
- All groups of order up to 2000, excluding the groups of order 1024.
- The groups whose order is the product of at most 4 primes.
- The groups of order dividing $p^7$ for $p$ a prime.
- The groups of order $3^8$.
- The groups of order $q^n p$, where $q^n$ is a prime-power dividing $2^8$, $3^6$, $5^5$ or $7^4$ and $p$ is a prime different to $q$.
- The groups of square-free order.
For a different mechanism for accessing the $p$-groups in this collection, see Section [The $p$-groups of Order Dividing $p^7$](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/p-groups.md#chapgrppgp), specifically the functions `SearchPGroups` and `CountPGroups`. These functions also access groups of order $p^7$.
$p$*-groups*: Magma contains the means to construct all $p$-groups of order $p^n$ where $n\le 7$. The data used in the constructions was supplied by Hans Ulrich Besche, Bettina Eick, Eamonn O’Brien, Mike Newman, and Michael Vaughan-Lee [[BE99a](https://docs.magma-maths.org/references.md#cite-besche-eick-constr), [BE99b](https://docs.magma-maths.org/references.md#cite-besche-eick-1000), [BE01](https://docs.magma-maths.org/references.md#cite-besche-eick-order-qnp), [BEO01](https://docs.magma-maths.org/references.md#cite-besche-eick-obrien-order-2000), [MNVL04](https://docs.magma-maths.org/references.md#cite-newman-ob-vl-04), [OBr90](https://docs.magma-maths.org/references.md#cite-obrien-pgroup), [OBr91](https://docs.magma-maths.org/references.md#cite-obrien-groups-256), [OVL05](https://docs.magma-maths.org/references.md#cite-ob-vl-05)].
*Metacyclic* $p$*-groups*: Magma is able to construct all metacyclic groups of order $p^n$. This machinery was developed by Mike Newman, Eamonn O’Brien, and Michael Vaughan-Lee.
*Perfect Groups*: This database contains all perfect groups up to order 50000, and many classes of perfect groups up to order one million. Each group is defined by means of a finite presentation. Further information is also provided which allows the construction of permutation representations. This database was constructed by Derek Holt and Willem Plesken [[HP89](https://docs.magma-maths.org/references.md#cite-holt-plesken)].
*Almost Simple Groups:* This database contains information about every group $G$, where $S \leq G \leq \Aut(S)$ and $S$ is a simple group of order less than 16000000, or $S$ is one of $M_{24}$, $HS$, $J_3$, $McL$, $Sz(32)$, or $L_6(2)$.
*Transitive Permutation Groups*: This database is a Magma version of the database of transitive permutation groups constructed by A. Hulpke [[Hul05](https://docs.magma-maths.org/references.md#cite-hulpketrans)] (for degree up to 30), J. Cannon and D. Holt [[CH08](https://docs.magma-maths.org/references.md#cite-trans32)] (degree 32), D. Holt and G. Royle [[HR19](https://docs.magma-maths.org/references.md#cite-holtroyle)] (degrees 33 to 47), and D. Holt (degree 48). It contains all transitive permutation groups, up to conjugacy in the ambient symmetric group, having degree up to 48.
*Primitive Permutation Groups*: This is a database containing all primitive permutation groups having degree up to 8191 as determined by Sims (for degree $\le 50$), Roney-Dougal and Unger [[RDU03](https://docs.magma-maths.org/references.md#cite-prim1000)] (for degree $< 1000$), Roney-Dougal [[RD05](https://docs.magma-maths.org/references.md#cite-prim2500)] (for degree $< 2500$), Coutts, Quick, and Roney-Dougal [[CQRD11](https://docs.magma-maths.org/references.md#cite-prim4096)] (for degree $< 4096$), and Stratford (for degree $< 8192$).
*Rational Maximal Matrix Groups*: This contains the rational maximal finite matrix groups and their invariant forms, for small dimensions (up to 31) as determined by Gabi Nebe and Willem Plesken [[Neb96](https://docs.magma-maths.org/references.md#cite-nebe-ratgps-31), [NP95](https://docs.magma-maths.org/references.md#cite-nebe-plesken-ratgps)]. Each entry can be accessed either as a matrix group or as a lattice.
*Quaternionic Matrix Groups*: A database of the finite absolutely irreducible subgroups of ${\operatorname{GL}}_n({\cal D})$ where ${\cal D}$ is a definite quaternion algebra whose centre has degree $d$ over ${\mathbb{Q}}$ and $nd\leq10$. Each entry can be accessed either as a matrix group or as a lattice. The database was constructed by Gabi Nebe [[Neb98](https://docs.magma-maths.org/references.md#cite-nebe-quaternionic)].
*Irreducible Matrix Groups*: A database of the irreducible subgroups of $\GL_n(p)$, $p$ prime, $n \ge 1$, and $p^n < 2500$. The groups were determined by Colva Roney-Dougal and William Unger [[RDU03](https://docs.magma-maths.org/references.md#cite-prim1000)] (for $p^n < 1000$) and Roney-Dougal [[RD05](https://docs.magma-maths.org/references.md#cite-prim2500)].
*Soluble Irreducible Groups*: This database contains one representative of each conjugacy class of irreducible soluble subgroups of ${\rm GL}(n,p)$, $p$ prime, for $n > 1$ and $p^n < 256$. It was constructed by Mark Short [[Sho92](https://docs.magma-maths.org/references.md#cite-short)].
*ATLAS Groups*: This database contains representations of nearly simple groups, as in the Birmingham ATLAS of Finite Group Representations. The data was supplied by Rob Wilson.
*Fundamental Groups of 3-Manifolds*: This database consists of the fundamental groups of the 10,986 small-volume closed hyperbolic manifolds in the Hodgson–Weeks census.
*Automatic Groups of 3-Manifolds*: This database contains automatic groups for 5,389 of the 10,986 small-volume closed hyperbolic manifolds in the Hodgson–Weeks census.
### Database of Simple Groups
The database of simple groups of order less than $10^{20}$ is intended to make it easy for a user to access any of the small simple groups. There are 403,874 simple groups in the database. The groups are arranged in order of increasing cardinality which makes it trivial to scan the simple groups of small order.
#### `SimpleGroup(N): RngIntElt -> Grp`
#### `SimpleGroup(S): MonStgElt -> Grp`
#### `SimpleGroup(T): Tup -> Grp`
This intrinsic returns a group isomorphic to the simple group specified in the argument. The simple group can be specified by any one of the following:-
- An integer $N$ that is the number of the requested simple group in the database.
- A string $S$ giving the standard name of the simple group.
- A tuple $T$ containing three integers that give the internal designation of the simple group.
The group returned is generally a permutation group of smallest degree that is isomorphic to the simple group, but there are cases where a matrix group is returned.
#### `SimpleGroupOfOrder(M): RngIntElt -> Grp`
#### `SimpleGroup(F): RngIntEltFac -> Grp`
A group isomorphic to a simple group whose order is given by the argument. The order may be an integer $M$ or a factored integer $F$.
#### `NumberOfSimpleGroups() -> RngIntElt`
The number of groups in the simple groups database.
#### `SimpleGroupName(N): RngIntElt -> MonStgElt`
This intrinsic returns a standard name of the simple group which has database number $N$.
#### `SimpleGroupNameToNumber(S): MonStgElt -> RngIntElt`
This intrinsic returns the database number of the simple group which has standard name $S$.
#### `SimpleGroupIDToNumber(T): Tup -> RngIntElt`
This intrinsic returns the database number of the simple group whose internal designation is $T$.
#### `SimpleGroupID(N): RngIntElt -> Tup`
This intrinsic returns the tuple identifying the simple group with database number $N$.
### Database of Small Groups
Magma includes the Small Groups Library prepared by Besche, Eick, and O’Brien. For a description of the algorithms used to generate these groups, details on the data structures used, and applications we refer to [[BE99a](https://docs.magma-maths.org/references.md#cite-besche-eick-constr), [BE99b](https://docs.magma-maths.org/references.md#cite-besche-eick-1000), [BE01](https://docs.magma-maths.org/references.md#cite-besche-eick-order-qnp), [BEO01](https://docs.magma-maths.org/references.md#cite-besche-eick-obrien-order-2000), [DEP22](https://docs.magma-maths.org/references.md#cite-dep4primes), [MNVL04](https://docs.magma-maths.org/references.md#cite-newman-ob-vl-04), [OBr90](https://docs.magma-maths.org/references.md#cite-obrien-pgroup), [OBr91](https://docs.magma-maths.org/references.md#cite-obrien-groups-256)] and the references therein.
The Small Groups Library contains the following groups.
- All groups of order up to 2000, excluding the groups of order 1024.
- The groups whose order is a product of at most 4 (not necessarily distinct) primes.
- The groups of order dividing $p^7$ for $p$ a prime.
- The groups of order $3^8$.
- The groups of order $q^n p$, where $q^n$ is a prime-power dividing $2^8$, $3^6$, $5^5$ or $7^4$ and $p$ is a prime different to $q$.
- The groups of square-free order.
The descriptions of the groups of order $p^4, p^5, p^6$ for $p>3$ were contributed by Boris Girnat, Robert McKibbin, M.F. Newman, E.A. O’Brien, and M.R. Vaughan-Lee.
The Magma version of this library uses the same internal data format as the implementation available in GAP. In particular, the numbering of the groups of a given order in both packages is the same.
For a different mechanism for accessing the $p$-groups in this collection, see the [The $p$-groups of Order Dividing $p^7$](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/p-groups.md#chapgrppgp) section, specifically the functions `SearchPGroups` and `CountPGroups`. These functions also access the groups of order $p^7$ (contributed by O’Brien and Vaughan-Lee).
The groups of order $3^8$ (also contributed by O’Brien and Vaughan-Lee) form an optional database that must be downloaded separately.
#### Basic Small Group Functions
Many of the functions in this section have an optional parameter `Search`. It can be used to limit the small group search to soluble (`Search := "Soluble"`) or insoluble (`Search := "Insoluble"`) groups. The default is `Search := "All"`, which allows all groups to be considered.
When a group is extracted from the database, it is returned as a [`GrpPC`](https://docs.magma-maths.org/FiniteGroups/FiniteSolubleGroups/index-finite-soluble-groups.md#chapgrppc) if it is soluble, or as a [`GrpPerm`](https://docs.magma-maths.org/FiniteGroups/PermutationGroups/index-permutation-groups.md#chapgrpperm) if it is insoluble.
When using the small groups database for an extended search, it is advisable to open the database using the function [`SmallGroupDatabase`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-grpdata-smallgroupdatabase), which opens the database and returns a reference to it. This reference can then be passed as first argument to most of the functions described below, and will save that function from opening and closing the database for itself. Doing so will reduce the number of file operations when a lot of use is made of the database. When the database is no longer needed, it can be closed using the [`delete D`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#operation-grpdata-delete) statement.
##### `SmallGroupDatabase() -> DB`
##### `OpenSmallGroupDatabase() -> DB`
Open the small groups database (for extended search) and return a reference to it. This reference may be passed to other functions so that they do fewer file operations.
##### `delete D: DB`
Close the small groups database `D` and free the resources associated with its use.
##### `SmallGroupDatabaseLimit() -> RngIntElt`
##### `SmallGroupDatabaseLimit(D): DB -> RngIntElt`
The limiting order up to which all groups (except those of order 1024) are stored in the database of small groups, that is, currently 2000.
##### `IsInSmallGroupDatabase(o): RngIntElt -> BoolElt`
##### `IsInSmallGroupDatabase(D, o): DB, RngIntElt -> BoolElt`
Return `true` if the groups of order $o$ are contained in the database and `false` otherwise. This function can be used to check whether $o$ is a legitimate argument for other functions described in this section, avoiding runtime errors in user written loops or functions.
##### `NumberOfSmallGroups(o): RngIntElt -> RngIntElt`
##### `NumberOfSmallGroups(D, o): DB, RngIntElt -> RngIntElt`
Given a positive integer $o$, return the number of groups of order $o$ in the database. If the groups of order $o$ are not contained in the database, 0 is returned. This function can be used to check whether a pair $o$, $n$ defines a group contained in the small groups database, that is, whether it is a legitimate argument for other functions described in this section, avoiding runtime errors in user written loops or functions.
##### `SmallGroup(o, n): RngIntElt, RngIntElt -> Grp`
##### `SmallGroup(D, o, n): DB, RngIntElt, RngIntElt -> Grp`
##### `Group(D, o, n): DB, RngIntElt, RngIntElt -> Grp`
Given a positive integer $o$, such that the groups of order $o$ are contained in the small groups library, and a positive integer $n$, return the $n$-th group of order $o$ in the database. If the groups of order $o$ are not contained in the database or if $n$ exceeds the number of groups of order $o$ in the database, an error is reported. The function [`NumberOfSmallGroups`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-grpdata-numberofsmallgroups) can be used to check whether the arguments are valid.
##### `SmallGroup(o: parameters): RngIntElt -> Grp`
##### `SmallGroup(D, o: parameters): DB, RngIntElt -> Grp`
```magma
Search: MonStgElt Default: "All"
```
Given a positive integer $o$, such that the groups of order $o$ are contained in the small groups library, return the first group of order $o$ in the database meeting the search criterion set by the parameter `Search`. If the groups of order $o$ are not contained in the database, an error is reported. The function [`IsInSmallGroupDatabase`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-grpdata-isinsmallgroupdatabase) can be used to check whether $o$ is a valid argument for this function.
##### `SmallGroup(o, f: parameters): RngIntElt, Program -> Grp`
##### `SmallGroup(D, o, f: parameters): RngIntElt, Program -> Grp`
```magma
Search: MonStgElt Default: "All"
```
Given a positive integer $o$ such that the groups of order $o$ are contained in the small groups library and a predicate $f$ (as a function or intrinsic), return the first group of order $o$ in the database meeting the search criterion set by the parameter `Search`, which satisfies $f$.
##### `IsSoluble(D, o, n): DB, RngIntElt, RngIntElt -> Grp`
##### `IsSolvable(D, o, n): DB, RngIntElt, RngIntElt -> Grp`
##### `SmallGroupIsSoluble(o, n): RngIntElt, RngIntElt -> Grp`
##### `SmallGroupIsSoluble(D, o, n): DB, RngIntElt, RngIntElt -> Grp`
##### `SmallGroupIsSolvable(o, n): RngIntElt, RngIntElt -> Grp`
##### `SmallGroupIsSolvable(D, o, n): DB, RngIntElt, RngIntElt -> Grp`
Return `true` iff `SmallGroup(o, n)` is soluble. This function does not load the group. If the group specified by the arguments does not exist in the database, an error is reported. The function [`NumberOfSmallGroups`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-grpdata-numberofsmallgroups) can be used to check whether the arguments are valid.
##### `SmallGroupIsInsoluble(o, n): RngIntElt, RngIntElt -> Grp`
##### `SmallGroupIsInsoluble(D, o, n): DB, RngIntElt, RngIntElt -> Grp`
##### `SmallGroupIsInsolvable(o, n): RngIntElt, RngIntElt -> Grp`
##### `SmallGroupIsInsolvable(D, o, n): DB, RngIntElt, RngIntElt -> Grp`
Return `true` iff `SmallGroup(o, n)` is insoluble. This function does not load the group. If the group specified by the arguments does not exist in the database, an error is reported. The function [`NumberOfSmallGroups`](https://docs.magma-maths.org/FiniteGroups/DatabasesOfGroups/smlgps-database.md#function-grpdata-numberofsmallgroups) can be used to check whether the arguments are valid.
##### `SmallGroup(o, f: parameters): RngIntElt, Program -> Grp`
##### `SmallGroup(S, f: parameters): [RngIntElt], Program -> Grp`
##### `SmallGroup(D, o, f: parameters): DB, RngIntElt, Program -> Grp`
##### `SmallGroup(D, S, f: parameters): DB, [RngIntElt], Program -> Grp`
```magma
Search: MonStgElt Default: "All"
```
Given a sequence $S$ of orders or a single order $o$ contained in the database and a predicate $f$ (as a function or intrinsic), return the first group with order in $S$ or equal to $o$, respectively, which meets the search criterion set by the parameter `Search` and satisfies $f$.
##### `SmallGroups(o: parameters): RngIntElt -> [* Grp *]`
##### `SmallGroups(D, o: parameters): DB, RngIntElt -> [* Grp *]`
```magma
Search : MonStgElt Default: "All"
Warning: BoolElt Default: true
```
Given an order $o$ contained in the database, return a list of all groups of order $o$, meeting the search criterion set by the parameter `Search`. Some orders will produce a very large sequence of groups – in such cases a warning will be printed unless the user specifies `Warning := false`.
##### `SmallGroups(S: parameters): [RngIntElt] -> [* Grp *]`
##### `SmallGroups(D, S: parameters): DB, [RngIntElt] -> [* Grp *]`
```magma
Search : MonStgElt Default: "All"
Warning: BoolElt Default: true
```
Given a sequence $S$ of orders contained in the database, return a list of all groups with order in $S$, meeting the search criterion set by the parameter `Search`. The resulting sequence may be very long – in such cases a warning will be printed unless the user specifies `Warning := false`.
##### `SmallGroups(o, f: parameters): RngIntElt, Program -> [* Grp *]`
##### `SmallGroups(D, o, f: parameters): DB, RngIntElt, Program -> [* Grp *]`
```magma
Search: MonStgElt Default: "All"
```
Given an order $o$ contained in the database and a predicate (function or intrinsic) $f$, return a list containing all groups $G$ of order $o$, meeting the search criterion set by the parameter `Search` and satisfying `f(G) eq true`.
##### `SmallGroups(S, f: parameters): [RngIntElt], Program -> [* Grp *]`
##### `SmallGroups(D, S, f: parameters): DB, [RngIntElt], Program -> [* Grp *]`
```magma
Search: MonStgElt Default: "All"
```
Given a sequence $S$ of orders contained in the database and a predicate (function or intrinsic) $f$, return a list containing all groups $G$ with order in $S$, meeting the search criterion set by the parameter `Search` and satisfying `f(G) eq true`.
##### `Example: Non-Abelian Groups of Order 27 (ex-dd4fa3)`
**(1)**
We find the non-abelian groups of order 27.
```magma
> list := SmallGroups(27, func );
> list;
[*
GrpPC of order 27 = 3^3
PC-Relations:
$.2^$.1 = $.2 * $.3,
GrpPC of order 27 = 3^3
PC-Relations:
$.1^3 = $.3,
$.2^$.1 = $.2 * $.3
*]
```
**(2)**
We get the first group in the database with derived length greater than 2.
```magma
> G := SmallGroup([1..100], func