|
Magma has a database containing all primitive permutation groups with
degree less than 8192.
The list of primitive groups up to degree 50 was prepared by C. C. Sims
(see [Sim70] for the early part of the list). The list up
to degree 999 was determined by Roney-Dougal and Unger.
See [RDU03] for details of the methods used. The list was extended
to degree 2499 by Roney-Dougal, as described in [RD05], and was
further extended to degree 4095 by Coutts, Quick, and Roney-Dougal
[CQRD11].
The groups of degrees 4096 to 8191 were provided by Ben Stratford.
Within the database the groups are stored by degree. Within each
degree they are stored by O'Nan--Scott class in the order
soluble affine, insoluble affine, diagonal action, product action,
almost simple. Within each class groups are ordered by increasing size.
(It follows that the alternating and symmetric groups
come last at each degree.)
The basic access function takes two parameters, degree and number,
and returns the corresponding primitive group. Functions with name
prefixed by NumberOfPrimitive tell how many groups of each class
there are stored.
We recommend the use of the PrimitiveGroupProcess or
PrimitiveGroups functions, with appropriate Filter value,
to access all primitive groups in a specific class.
The limiting degree of the database of primitive groups.
NumberOfPrimitiveSolubleGroups(d) : RngIntElt -> RngIntElt
NumberOfPrimitiveAffineGroups(d) : RngIntElt -> RngIntElt
NumberOfPrimitiveDiagonalGroups(d) : RngIntElt -> RngIntElt
NumberOfPrimitiveProductGroups(d) : RngIntElt -> RngIntElt
NumberOfPrimitiveAlmostSimpleGroups(d) : RngIntElt -> RngIntElt
Given a degree d in the required range, NumberOfPrimitiveGroups
returns the number of primitive groups of degree d. The other functions
return the number of groups of each class at that degree.
Given a degree d in the required range and a positive integer n,
return the n-th primitive group of degree d.
Also returns a string (possibly empty) giving a description of the
group and a string giving the group's O'Nan--Scott type.
A string giving a description of the n-th primitive group of degree d.
Given a degree d in the required range,
return the first primitive group of degree d.
Also returns a string giving a description of the group and a string
giving the group's O'Nan--Scott type.
Given a degree d in the required range and a predicate f
(as a function or intrinsic), return the first transitive (primitive)
group of degree d
which satisfies f.
Given a sequence S of degrees and a predicate f
(as a function or intrinsic), return the first transitive (primitive)
group with degree in S which satisfies f.
Filter: MonStgElt Default: "All"
Return a sequence of all primitive groups of degree d, modified by the value
assigned to Filter. The possible values for the parameter are the strings
All, Soluble, Affine, Diagonal, Product, AlmostSimple, Simple and SimpleNA. Generally these values restrict
the list to groups in the appropriate O'Nan--Scott type, with the exceptions
being All giving no restriction, Simple restricting to a lsit of
all simple groups in the database, and SimpleNA being as for Simple
but omitting all alternating groups in their natural representations.
PrimitiveGroups( : parameters) : -> [GrpPerm]
Filter: MonStgElt Default: "All"
Given a sequence S of degrees, return a sequence of all
primitive groups with degree in S. The result is modified by Filter
with values as above. Omitting the sequence of degrees gives the same result as
specifying all legal degrees.
PrimitiveGroups(S, f) : [RngIntElt], Program -> [GrpPerm]
PrimitiveGroups(f) : Program -> [GrpPerm]
Filter: MonStgElt Default: "All"
Given an integer d and a predicate (function or intrinsic) f, return a
sequence containing all primitive groups G of degree d passing the filter
satisfying f(G) eq true. Note that the filter will be generally much
quicker in rejecting candidates than the predicate will be, and only groups
passing the filter have f(G) evaluated.
Instead of giving a single degree, a sequence of degrees may be given.
Omitting the degree is the same as specifying the sequence of all legal
degrees.
We apply some of these functions to the degree 625 case.
> NumberOfPrimitiveGroups(625);
698
> NumberOfPrimitiveAffineGroups(625);
647
> NumberOfPrimitiveSolubleGroups(625);
509
> NumberOfPrimitiveDiagonalGroups(625);
0
> NumberOfPrimitiveProductGroups(625);
49
> NumberOfPrimitiveAlmostSimpleGroups(625);
2
> PrimitiveGroup(625, 511);
Permutation group acting on a set of cardinality 625
Order = 150000 = 2^4 * 3 * 5^5
5^4:SL(2, 5).2 Affine
> PrimitiveGroup(625,690);
Permutation group acting on a set of cardinality 625
Order = 2^14 * 3^5 * 5^4
Alt(5)^4:Q_8:Sym(4) ProductAction
> Q := PrimitiveGroups(625, func<G|#G eq 3*10^4>
> : Filter := "Affine");
> #Q;
26
A primitive group process enables iteration over all primitive
groups of specified degrees satisfying a given predicate, without
having to create and store a list of all such groups.
The intrinsic function PrimitiveGroupProcess may be used to create
a primitive group process. The standard process functions IsEmpty,
Current, CurrentLabel and Advance can then be applied
to the process.
PrimitiveGroupProcess(S: parameters) : [RngIntElt] -> Process
PrimitiveGroupProcess(: parameters) : -> Process
Filter: MonStgElt Default: "All"
Return a group process which will iterate though all primitive
groups of degree d that pass the filter as described above.
A sequence of degrees may be given instead of a single degree. In this case
the process will iterate though the groups of all the degrees in S.
Omitting any degree information is the same as specifying the
sequence of all legal degrees.
PrimitiveGroupProcess(S, f: parameters) : [RngIntElt], Program -> Process
PrimitiveGroupProcess(f: parameters) : Program -> Process
Filter: MonStgElt Default: "All"
Return a process which will iterate though all primitive
groups with degree d which pass the filter and satisfy the predicate f.
A sequence of degrees may be given instead of a single degree. In this case
the process will iterate though the groups of all the degrees in S.
Omitting any degree information is the same as specifying the
sequence of all legal degrees.
Returns true if the process p has passed its last group.
Return the current group of the process p, as well as a description
of the group.
Return the label of the current group of the process p.
That is, return d and n such that the current group is
TransitiveGroup(d, n) (or PrimitiveGroup(d, n)).
Move the process p to its next group.
The use of processes is illustrated by the following code, in which the
orders of all primitive groups with degree 60 of diagonal type are
listed.
We also compute the orbit structures of their Sylow 2-subgroups, which
demonstrates that they are non-conjugate.
> p := PrimitiveGroupProcess(60:Filter:="Diagonal");
> while not IsEmpty(p) do
> G := Current(p);
> CurrentLabel(p), #G,
> [t[1]:t in OrbitRepresentatives(Sylow(G,2))];
> Advance(~p);
> end while;
60 1 3600 [ 4, 4, 4, 16, 16, 16 ]
60 2 7200 [ 4, 4, 4, 16, 32 ]
60 3 7200 [ 4, 8, 16, 32 ]
60 4 7200 [ 4, 8, 16, 16, 16 ]
60 5 14400 [ 4, 8, 16, 32 ]
Given a primitive group G whose degree is at most 2499,
it is possible to obtain the number of the group in the primitive groups
database which is permutation isomorphic to G.
The number (and degree) of the group in the primitive groups
database which is permutation isomorphic to the primitive group G.
We construct a permutation group of affine type
and identify it as a primitive group.
> M := WreathProduct(SL(2,5), Sym(2));
> Q := Getvecs(M);
> G := Semidir(M, Q);
> G;
Permutation group G acting on a set of cardinality 625
> PrimitiveGroupIdentification(G);
595 625
We found it to be group 595 of degree 625.
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|