Transfer Between Group Categories

Contents

Transfer to GrpPC

The PolycyclicGroup-constructor allows complete flexibility in defining a pc-group. However, it is often more convenient to have Magma compute a pc-presentation based on some other description of the group. The PCGroup function will produce a pc-presentation for a finite group in various categories such as GrpPerm and GrpMat. Converting from a FINITELY PRESENTED GROUPS group is trickier, since the original group need not be finite. There are two functions provided to produce pc-presentations for certain quotients of finitely-presented groups. The pQuotient function constructs a pc-presentation for the largest p-group quotient having specified lower exponent-p class. Similarly, SolubleQuotient will compute the largest soluble quotient subject to certain restrictions. Each of these functions also provides a homomorphism (isomorphism in the case of PCGroup) from the original group to the new pc-group. More information on each of the two quotient functions can be found in Chapter FINITELY PRESENTED GROUPS.

PCGroup(G) : GrpPerm -> GrpPC, Map
PCGroup(G) : GrpMat -> GrpPC, Map
[Future release] PCGroup(G) : GrpFP -> GrpPC
A GrpPC representation of the group G and the isomorphism.
pQuotient(F, p, c : parameters ) : GrpFP, RngIntElt, RngIntElt -> GrpPC, Map
    Workspace: RngIntElt                Default: 1000000
    Metabelian: BoolElt                 Default: false
    Exponent: RngIntElt                 Default: 0
    Print: RngIntElt                    Default: 0
Given a finitely presented group F, a prime p, and a positive integer c, this function constructs a consistent power-conjugate presentation for the largest p-quotient H of F having lower exponent-p class at most c. If c is given as zero, then the limit 127 is placed on the class. The function returns both the p-quotient H defined by a pc-presentation and the homomorphism from F to H.
SolubleQuotient(G) : Grp -> GrpPC, Map
SolvableQuotient(G) : Grp -> GrpPC, Map
A GrpPC representation P of the largest solvable quotient of G and the homomorphism φ: G -> P.

Example GrpPC_pcgroup (H69E33)

We use PCGroup to produce a pc-presentation for a matrix group.
> GL := GeneralLinearGroup(4,GF(3));
> S3 := Sylow(GL,3);
> P := PCGroup(S3);
> P;
GrpPC : P of order 729 = 3^6
PC-Relations:
    P.2^P.1 = P.2 * P.4^2,
    P.3^P.1 = P.3 * P.5^2,
    P.3^P.2 = P.3 * P.6^2,
    P.5^P.2 = P.4 * P.5,
    P.6^P.1 = P.4 * P.6

Transfer from GrpPC

Given a pc-group, it is straight-forward to convert it to a FINITELY PRESENTED GROUPS or GrpGPC representation by using the appropriate transfer function. If one wishes to have a permutation representation of the group, this requires more cleverness. The CosetAction function can be used to compute the permutation representation of a group on a subgroup. If the subgroup is chosen to have trivial core, then the permutation group obtained will be isomorphic to the original group.

AbelianGroup(G) : GrpPC -> GrpAb, Map
Given an abelian pc-group G, return a GrpAb group H isomorphic to G and an isomorphism φ: G -> H.
FPGroup(G) : GrpPC -> GrpFP, Map
A FINITELY PRESENTED GROUPS representation F of G and the isomorphism from G to F.
GPCGroup(G) : GrpPC -> GrpGPC, Map
A GrpGPC representation F of G and the isomorphism from G to F.

Example GrpPC_pc-to-perm (H69E34)

Take one of the groups of order 26 * 32.
> G := SmallGroup(576, 4123);
> G;
GrpPC : G of order 576 = 2^6 * 3^2
PC-Relations:
    G.1^2 = Id(G),
    G.2^2 = Id(G),
    G.3^2 = G.5,
    G.4^3 = Id(G),
    G.5^2 = G.7,
    G.6^2 = G.7,
    G.7^2 = Id(G),
    G.8^3 = Id(G),
    G.2^G.1 = G.2 * G.6,
    G.6^G.1 = G.6 * G.7,
    G.6^G.2 = G.6 * G.7,
    G.8^G.1 = G.8^2
Since G is small, we can search for a minimum degree permutation presentation by brute force. First we build a set containing all the subgroups.
> SL := Subgroups(G);
> T := {X`subgroup: X in SL};
> #T;
243
Then, we select those subgroups with trivial core, and find one with the smallest index.
> TrivCore := {H:H in T| #Core(G,H) eq 1};
> mdeg := Min({Index(G,H):H in TrivCore});
> Good := {H: H in TrivCore| Index(G,H) eq mdeg};
> #Good;
3
> H := Rep(Good);
We then use CosetAction to construct the permutation representation on the cosets of H.
> f,P,K := CosetAction(G,H);
> #K;
1
> IsPrimitive(P);
false
V2.28, 13 July 2023