# Database of Soluble Irreducible Groups This database contains one representative of each conjugacy class of irreducible soluble subgroups of ${\rm GL}(n,p)$, $p$ prime, They may be accessed through specifying a group by its label in the database, as described in the section on basic functions, or through searching using predicates, or through a process. The database was constructed by Mark Short [[Short, 1992](../../references.md#cite-short)]. ## Basic Functions The basic access functions for the database are described in this section. The label of a group in the database is three integers, $d$, $p$, $i$. The first, $d \ge 2$, is the degree of the matrix group. The second, a prime $p$, specifies the base field of the group. The third is the number of the group in this degree/field set. ### `IsolGroupDatabase() -> DB` Open the database and return a reference to it. This reference may be passed to other functions so that they do fewer file operations. ### `IsolGroup(n, p, i): RngIntElt, RngIntElt, RngIntElt -> GrpMat` ### `Group(D, n, p, i): DB, RngIntElt, RngIntElt, RngIntElt -> GrpMat` Given a positive integer $o \leq 1000$ (with $o \neq 512$ or $768$) and a positive integer $n$, return the $n$-th group of order $o$. ### `IsolNumberOfDegreeField(n, p): RngIntElt, RngIntElt -> RngIntElt` The number of groups in the database of degree $n$ over ${\bf F}_{p}$. ### `IsolInfo(n, p, i): RngIntElt, RngIntElt, RngIntElt -> MonStgElt` This function returns a string which gives some information about a group in the database given its label. In particular, it contains the order and primitivity information about the group. ### `IsolOrder(n, p, i): RngIntElt, RngIntElt, RngIntElt -> RngIntElt` This function returns the order of a group given its label. ### `IsolMinBlockSize(n, p, i): RngIntElt, RngIntElt, RngIntElt -> RngIntElt` This function returns the minimal block size of a group given its label. If it is primitive, it returns 0. ### `IsolIsPrimitive(n, p, i): RngIntElt, RngIntElt, RngIntElt -> BoolElt` This function returns whether a group is primitive given its label. ### `IsolGuardian(n, p, i): RngIntElt, RngIntElt, RngIntElt -> GrpMat` This function returns the “guardian” of a group given its label, i.e., the maximal subgroup of ${\operatorname{GL}}(n, p)$ of which the group is a subgroup. ### `Example: Isol Group (ex-f88165)` We find a group of degree 3 and its guardian. ```magma > IsolNumberOfDegreeField(3, 5); 22 > G := IsolGroup(3, 5, 10); > #G; 62 > GG := IsolGuardian(3, 5, 10); > #GG; 372 > G; MatrixGroup(3, GF(5)) of order 62 = 2 * 31 Generators: [0 0 1] [3 0 4] [2 3 1] > GG; MatrixGroup(3, GF(5)) of order 372 = 2^2 * 3 * 31 Generators: [1 0 0] [3 2 2] [1 4 2] [0 1 0] [0 0 1] [3 0 4] ``` ## Searching with Predicates We may search the database for a group satisfying some predicate. A predicate for a group in this database is one of the following: - A function $f$ (which may either be an intrinsic function or a user defined function) which takes a matrix group and returns a boolean value. - A tuple of one function $\langle g\rangle$, where $g$ takes a label and returns a boolean value. Again $g$ is either intrinsic or user defined. - A tuple of two functions $\langle g, f\rangle$ where $g, f$ are as above. In this case, the tested predicate will be $g$ first, then $f$. This form is introduced to avoid expanding the group from its label until absolutely necessary. ### `IsolGroupSatisfying(f): Any -> GrpMat` Given a predicate $f$, return a group satisfying it. This function runs through all the stored groups and applies the predicate until it finds a suitable one. If no group is found, an error message is printed. ### `IsolGroupOfDegreeSatisfying(d, f): RngIntElt, Any -> GrpMat` As `IsolGroupSatisfying(f)`, except it only runs through the groups of degree $d$. ### `IsolGroupOfDegreeFieldSatisfying(d, p, f): RngIntElt, RngIntElt, Any -> GrpMat` As `IsolGroupSatisfying(f)`, except it only runs through the groups of degree $d$ and defined over ${\bf F}_{p}$. ### `IsolGroupsSatisfying(f): Any -> SeqEnum` As `IsolGroupSatisfying(f)`, except a sequence of all such groups is returned. ### `IsolGroupsOfDegreeSatisfying(d, f): RngIntElt, Any -> SeqEnum` As `IsolGroupOfDegreeSatisfying(d, f)`, except a sequence of all such groups is returned. ### `IsolGroupsOfDegreeFieldSatisfying(d, p, f): RngIntElt, RngIntElt, Any -> SeqEnum` As `IsolGroupOfDegreeFieldSatisfying(d, p, f)`, except a sequence of all such groups is returned. ## Associated Functions Associated with this database are two functions which can be used for constructing the semidirect product of a finite vector space and an irreducible matrix group. In particular, they are useful for constructing soluble affine permutation groups. ### `Getvecs(G): GrpMat -> SeqEnum` The function takes a matrix group $G$ over a finite prime field and returns a sequence, $Q$ say, containing all the vectors of the natural module for $G$. The ordering of $Q$ does *not* depend on $G$, but only on its natural module. ### `Semidir(G, Q): GrpMat, SeqEnum -> GrpPerm` Given an irreducible matrix group $G$ of degree $n$ defined over a finite prime field of cardinality $p$ and the sequence $Q$ obtained from `Getvecs`, this function returns the permutation group $H$ of degree $p^n$, that is, the semidirect product of $G$ with its natural module. The group $H$ acts on the set $\{1\dots p^n\}$ and $G$ is isomorphic to each of the point stabilizers. It is well known that $H$ is primitive, and that every primitive permutation group with soluble socle arises in this way. Note that if `Semidir` is to be called more than once for subgroups of the same general linear group, then `Getvecs` need only be called on the first occasion, since the ordering of $Q$ depends only on $n$ and $p$. This is why the call to `Getvecs` is not made by `Semidir` itself. ## Processes A small group process enables iteration over all groups with specified degrees and fields, without having to create and store all such groups together. A process is created via the function `IsolProcess` and its variants. The standard process functions `IsEmpty`, `Current`, `CurrentLabel` and `Advance` can then be applied to the process. A specifier for degree or field is one of a valid degree (field size), or a tuple $\langle l, h\rangle$, of valid degrees (field sizes) which is interpreted to mean all degrees (prime field sizes) in $[l, h]$. ### `IsolProcess() -> Process` Return a process which will iterate though all groups in the database. ### `IsolProcessOfDegree(d): . -> Process` Return a process which will iterate though all groups in the database of degree $d$. ### `IsolProcessOfField(p): . -> Process` Return a process which will iterate though all groups in the database over the specified field. ### `IsolProcessOfDegreeField(d, p): ., . -> Process` Return a process for iterating over all the stored groups with degree specifier $d$ and field specifier $p$. Initially it points to the first such group (the principal key is the degree). ### `IsEmpty(p): Process -> BoolElt` Returns `true` if the process $p$ has passed its last group. ### `Current(p): Process -> GrpMat` Return the current group of the process $p$. ### `CurrentLabel(p): Process -> RngIntElt, RngIntElt, RngIntElt` Return the label of the current group of the process $p$. That is, return $d$, $n$ and $i$ such that the current group is `IsolGroup(d, n, i)`. ### `Advance(~p): Process` Move the process $p$ to its next group. ### `Example: Sg Process (ex-4ef256)` We use a small group process to look at all the groups of degree 3. ```magma > P := IsolProcessOfDegree(3); > ords := {* *}; > repeat > Include(~ords, #Current(P)); > Advance(~P); > until IsEmpty(P); > ords; {* 31, 62, 93, 7, 124, 96^^4, 39, 12^^2, 186, 13, 192^^2, 48^^4, 21, 24^^6, 26 *} ```