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 prime \(p\) must be less than \(65536\). 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: Pc-Presentation of a Matrix Group (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 (opens in a new tab)Copy input

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-Group to Permutation Group (ex-b68da2)

Run in calculator (opens in a new tab)Copy input

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

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

Run in calculator (opens in a new tab)Copy input