# 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 [[Detinko *et al.*, 2011](../../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 [[Detinko and Flannery, 2008](../../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 [[Detinko and Flannery, 2006](../../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 [[Detinko and Flannery, 2006](../../references.md#cite-large)]. If $K$ is infinite then the function is similar to the algorithm in [[Detinko and Flannery, 2008](../../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 [[Detinko *et al.*, 2011](../../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.