|
Magma includes a database of finite perfect groups. This database
includes 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.
There are three ways to key a particular entry of the database.
Firstly, a single integer i simply denotes the i-th entry of the
database. There is no particular ordering in the correspondence.
Secondly, the database stores information to quickly locate perfect groups
of a particular order; thus the pair o, i represents the i-th entry of
order o.
The third method corresponds to the notation used in Chapter 5.3
of [HP89].
In this book, the expression Q#p
denotes the class of groups that are isomorphic to perfect extensions
of p-groups by Q, where p is a prime and Q is a fixed finite
perfect group in which the largest normal p-subgroup is assumed to be
trivial. Within a class Q#p, an isomorphism type of groups is
denoted by an ordered pair of integers < r, n >, where
r≥0 and n≥0.
To specify a particular group Q without extension, a (somewhat
descriptive) string is given. The set of possible values can be
accessed using the function TopQuotients. Among these strings,
full or partial covering groups of G are named GCn where
n is the index of G in GCn. Also, there are five classes
of 3-extensions of groups which are also defined in the database. The
names of these base groups are A5{#2<r, n>} where
(r, n) are (4, 2), (5, 5), (5, 6), (5, 7) or (6, 7). Furthermore, there
are some extensions of direct products: these have names of the form
GxH. The remainder are names of simple groups. The
convention with these names is that if they are elements of a family of
simple groups with two parameters then the name will be fam(p1, p2), while one parameter families will just be the
concatenation of the family name and the parameter.
To illustrate the naming conventions, here are some examples:
A5, A5C2, A5{#2<5, 5>}, L(2, 59)C2,
A5xL(2, 11).
Notice that there is never a space before the C denoting a covering group
or on either side of the x denoting direct product. However, there is
always a space after a comma.
To specify a particular group Q(#)p< r, n > the four
values Q, p, r and n should be given. However, it should be
noted that in three cases (A5{#2<5, 1>},
L(3, 2){#2<3, 1>}, L(3, 2){#2<3, 2>}),
there are two versions of
Q{#p<r, n>} stored in the database. Strictly speaking,
then, there is a fifth key value v required in this third method.
However, it can be specified by an optional parameter Variant := v
(if necessary), and can normally be ignored. The variant forms are
isomorphic to the original forms, and are included for compatibility with
Holt & Plesken's tables.
This function returns a database object which contains information about the
database. It is required as first argument to the other access functions.
Group(D, o, i): DB, RngIntElt, RngIntElt -> GrpFP, SeqEnum
Group(D, Q): DB, MonStgElt -> GrpFP, SeqEnum
Group(D, Q, p, r, n: parameters): DB, MonStgElt, RngIntElt, RngIntElt, RngIntElt, RngIntElt -> GrpFP, SeqEnum
Variant: RngIntElt Default: 1
Returns the specified entry from the database D as a finitely presented
group. In addition, it returns a sequence of pairs < [i1, ..., in],
[H1, ..., Hn] >, each of which affords an isomorphism onto a
permutation group of degree ∑j=1n ij. The subgroup Hj has index
ij in the defined group, and the sum of the permutation representations
of the group on the cosets of the Hj's is faithful.
For the meanings of the arguments,
see Subsection Specifying an Entry of the Database above.
IdentificationNumber(D, o, i): DB, RngIntElt, RngIntElt -> RngIntElt
IdentificationNumber(D, Q): DB, MonStgElt -> RngIntElt
IdentificationNumber(D, Q, p, r, n: parameters): DB, MonStgElt, RngIntElt, RngIntElt, RngIntElt, RngIntElt -> RngIntElt
Variant: RngIntElt Default: 1
Returns a number which can be used to access the specified entry from the
database D using method one.
(See Subsection Specifying an Entry of the Database above).
NumberOfRepresentations(D, o, i): DB, RngIntElt, RngIntElt -> RngIntElt
NumberOfRepresentations(D, Q): DB, MonStgElt -> RngIntElt
NumberOfRepresentations(D, Q, p, r, n: parameters): DB, MonStgElt, RngIntElt, RngIntElt, RngIntElt, RngIntElt -> RngIntElt
Variant: RngIntElt Default: 1
Returns the number of ways stored in the database for building a
permutation group representation of the specified entry.
(See Subsection Specifying an Entry of the Database above).
PermutationRepresentation(D, o, i: parameters) : DB, RngIntElt, RngIntElt -> Hom(Grp), GrpFP, GrpPerm
PermutationRepresentation(D, Q: parameters): DB, MonStgElt -> Hom(Grp), GrpFP, GrpPerm
PermutationRepresentation(D, Q, p, r, n: parameters): DB, MonStgElt, RngIntElt, RngIntElt, RngIntElt, RngIntElt -> Hom(Grp), GrpFP, GrpPerm
Variant: RngIntElt Default: 1
Returns the isomorphism from the finitely presented group G specified to a
permutation group representation H as well as the groups G and H.
(See Subsection Specifying an Entry of the Database above).
Representation: RngIntElt Default: 1
Selects which of the stored methods of constructing the permutation
representation should be used.
PermutationGroup(D, o, i: parameters): DB, RngIntElt, RngIntElt -> GrpPerm
PermutationGroup(D, Q: parameters): DB, MonStgElt -> GrpPerm
PermutationGroup(D, Q, p, r, n: parameters): DB, MonStgElt, RngIntElt, RngIntElt, RngIntElt, RngIntElt -> GrpPerm
Variant: RngIntElt Default: 1
Returns the specified entry from the database D as a permutation group.
(See Subsection Specifying an Entry of the Database above).
Representation: RngIntElt Default: 1
Selects which of the stored methods of constructing the permutation
representation should be used.
NumberOfGroups(D) : DB -> RngIntElt
Returns the number of entries stored in the database.
(See Subsection Specifying an Entry of the Database, method 1, above).
Returns the number of entries stored in the database of order o.
(See Subsection Specifying an Entry of the Database, method 2, above).
Returns the set of strings denoting the fixed perfect groups Q.
(See Subsection Specifying an Entry of the Database, method 3, above).
Returns the set of primes p for which a non-trivial p-extension of the
group denoted by Q lies in the database.
(See Subsection Specifying an Entry of the Database, method 3, above).
Returns the set of exponents r such that a non-trivial extension of
the group denoted by Q by pr lies in the database.
(See Subsection Specifying an Entry of the Database, method 3, above).
Returns the set of numbers n such that there is a group
Q#p< r, n > in the database.
(See Subsection Specifying an Entry of the Database, method 3, above).
Returns the set of triples < p, r, n > such that there is
a group Q#p< r, n > in the database.
(See Subsection Specifying an Entry of the Database, method 3, above).
We hunt through the various levels of key-finding functions available to
find an extension of L(3,4) in the database.
> DB := PerfectGroupDatabase();
> "L(3, 4)" in TopQuotients(DB);
true
> ExtensionPrimes(DB, "L(3, 4)");
{ 2 }
> ExtensionExponents(DB, "L(3, 4)", 2);
{ 1, 2, 3, 4 }
> ExtensionNumbers(DB, "L(3, 4)", 2, 2);
{ 1, 2, 3 }
The database contains extensions of L(3,4) by groups of order 2 1, 2 2,
2 3 and 2 4.
We will look at one of the 3 extensions by a group of order 4.
> G := Group(DB, "L(3, 4)", 2, 2, 3);
> G;
Finitely presented group G on 3 generators
Relations
a^2 = Id(G)
b^4 * e^-2 = Id(G)
a * b * a * b * a * b * a * b * a * b * a * b * a * b * e
= Id(G)
a * b^2 * a * b^2 * a * b^2 * a * b^2 * a * b^2 * e^-1 =
Id(G)
a^-1 * b^-1 * a * b * a^-1 * b^-1 * a * b * a^-1 * b^-1 *
a * b * a^-1 * b^-1 * a * b * a^-1 * b^-1 * a * b * e^-2 =
Id(G)
a * b * a * b * a * b^3 * a * b * a * b * a * b^3 * a * b
* a * b * a * b^3 * a * b * a * b * a * b^3 * a * b * a *
b * a * b^3 * e^-2 = Id(G)
(a * b * a * b * a * b^2 * a * b^-1)^5 = Id(G)
(a, e^-1) = Id(G)
(b, e^-1) = Id(G)
> P := PermutationGroup(DB, "L(3, 4)", 2, 2, 3);
> P;
Permutation group P acting on a set of cardinality 224
Order = 80640 = 2^8 * 3^2 * 5 * 7
> ChiefFactors(P);
G
| A(2, 4) = L(3, 4)
*
| Cyclic(2)
*
| Cyclic(2)
1
> #Radical(P);
4
> IsCyclic(Radical(P));
true
> IsCentral(P, Radical(P));
true
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|