# 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](../../FinitelyPresentedGroups/FPGroups/index-fpgroups.md#chapgrpfp).

### `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`

```magma
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.

```magma
> 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 `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$.

```magma
> 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.

```magma
> 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.

```magma
> 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$.

```magma
> f,P,K := CosetAction(G,H);
> #K;
1
> IsPrimitive(P);
false

```