Transfer Between Group Categories#

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 GrpFP 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#
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 \(\phi: G\rightarrow P\).

Example: pcgroup (ex-84bae2)#

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

Run in calculator

Transfer from GrpPC#

Given a pc-group, it is straight-forward to convert it to a GrpFP 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 \(\phi: G \rightarrow H\).

FPGroup(G): GrpPC -> GrpFP, Map#: A GrpFP 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: Pc To Perm (ex-b68da2)#

Take one of the groups of order \(2^6 * 3^2\).

> 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

Run in calculator

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

Run in calculator

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);

Run in calculator

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

Run in calculator