|
This database contains one representative of each conjugacy class of
irreducible soluble subgroups of (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 [Sho92].
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 ≥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.
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 ≤1000 (with o != 512 or 768) and
a positive integer n, return the n-th group of order o.
The number of groups in the database of degree n over GF(p).
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.
This function returns the order of a group given its label.
This function returns the minimal block size of a group given
its label. If it is primitive, it returns 0.
This function returns whether a group is primitive given its label.
This function returns the "guardian" of a group given its label,
i.e., the maximal subgroup of GL(n, p) of which the group is a
subgroup.
We find a group of degree 3 and its guardian.
> 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]
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 < g >, where g takes a label
and returns a boolean value. Again g is either intrinsic or user defined.
- A tuple of two functions < g, f > 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.
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.
As IsolGroupSatisfying(f), except it only runs through the groups
of degree d.
As IsolGroupSatisfying(f), except it only runs through the groups
of degree d and defined over GF(p).
As IsolGroupSatisfying(f), except a sequence of all such groups
is returned.
As IsolGroupOfDegreeSatisfying(d, f), except a sequence of all
such groups is returned.
As IsolGroupOfDegreeFieldSatisfying(d, p, f), except a sequence of all
such groups is returned.
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.
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.
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 pn, that is,
the semidirect product of G with its natural module. The group H acts
on the set {1 ... pn} 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.
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 < l, h >, of valid degrees (field sizes) which is
interpreted to mean all degrees (prime field sizes) in [l, h].
Return a process which will iterate though all
groups in the database.
Return a process which will iterate though all
groups in the database of degree d.
Return a process which will iterate though all groups in the database
over the specified field.
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).
Returns true if the process p has passed its last group.
Return the current group of the process p.
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).
Move the process p to its next group.
We use a small group process to look at all the groups of
degree 3.
> 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 *}
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|