Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 Bib Ind

45 Polycyclic Groups

45.5 Elementary Operations for a Pcgs and an Element

45.5-1 RelativeOrderOfPcElement

45.5-2 ExponentOfPcElement

45.5-3 ExponentsOfPcElement

45.5-4 DepthOfPcElement

45.5-5 LeadingExponentOfPcElement

45.5-6 PcElementByExponents

45.5-7 LinearCombinationPcgs

45.5-8 SiftedPcElement

45.5-9 CanonicalPcElement

45.5-10 ReducedPcElement

45.5-11 CleanedTailPcElement

45.5-12 HeadPcElementByNumber

45.5-1 RelativeOrderOfPcElement

45.5-2 ExponentOfPcElement

45.5-3 ExponentsOfPcElement

45.5-4 DepthOfPcElement

45.5-5 LeadingExponentOfPcElement

45.5-6 PcElementByExponents

45.5-7 LinearCombinationPcgs

45.5-8 SiftedPcElement

45.5-9 CanonicalPcElement

45.5-10 ReducedPcElement

45.5-11 CleanedTailPcElement

45.5-12 HeadPcElementByNumber

45.11 Pcgs and Normal Series

45.11-1 IsPcgsElementaryAbelianSeries

45.11-2 PcgsElementaryAbelianSeries

45.11-3 IndicesEANormalSteps

45.11-4 EANormalSeriesByPcgs

45.11-5 IsPcgsCentralSeries

45.11-6 PcgsCentralSeries

45.11-7 IndicesCentralNormalSteps

45.11-8 CentralNormalSeriesByPcgs

45.11-9 IsPcgsPCentralSeriesPGroup

45.11-10 PcgsPCentralSeriesPGroup

45.11-11 IndicesPCentralNormalStepsPGroup

45.11-12 PCentralNormalSeriesByPcgsPGroup

45.11-13 IsPcgsChiefSeries

45.11-14 PcgsChiefSeries

45.11-15 IndicesChiefNormalSteps

45.11-16 ChiefNormalSeriesByPcgs

45.11-17 IndicesNormalSteps

45.11-18 NormalSeriesByPcgs

45.11-1 IsPcgsElementaryAbelianSeries

45.11-2 PcgsElementaryAbelianSeries

45.11-3 IndicesEANormalSteps

45.11-4 EANormalSeriesByPcgs

45.11-5 IsPcgsCentralSeries

45.11-6 PcgsCentralSeries

45.11-7 IndicesCentralNormalSteps

45.11-8 CentralNormalSeriesByPcgs

45.11-9 IsPcgsPCentralSeriesPGroup

45.11-10 PcgsPCentralSeriesPGroup

45.11-11 IndicesPCentralNormalStepsPGroup

45.11-12 PCentralNormalSeriesByPcgsPGroup

45.11-13 IsPcgsChiefSeries

45.11-14 PcgsChiefSeries

45.11-15 IndicesChiefNormalSteps

45.11-16 ChiefNormalSeriesByPcgs

45.11-17 IndicesNormalSteps

45.11-18 NormalSeriesByPcgs

A group `G` is *polycyclic* if there exists a subnormal series \(G = C_1 > C_2 > \ldots > C_n > C_{{n+1}} = \{ 1 \}\) with cyclic factors. Such a series is called *pc series* of `G`.

Every polycyclic group is solvable and every finite solvable group is polycyclic. However, there are infinite solvable groups which are not polycyclic.

In **GAP** there exists a large number of methods for polycyclic groups which are based upon the polycyclic structure of these groups. These methods are usually very efficient, especially for groups which are given by a pc-presentation (see chapter 46), and can be applied to many types of groups. Hence **GAP** tries to use them whenever possible, for example, for permutation groups and matrix groups over finite fields that are known to be polycyclic (the only exception is the representation as finitely presented group for which the polycyclic methods cannot be used in general).

At the current state of implementations the **GAP** library contains methods to compute with finite polycyclic groups, while the **GAP** package **Polycyclic** by Bettina Eick and Werner Nickel allows also computations with infinite polycyclic groups which are given by a pc-presentation.

Let `G` be a polycyclic group with a pc series as above. A *polycyclic generating sequence* (*pcgs* for short) of `G` is a sequence \(P := (g_1, \ldots, g_n)\) of elements of `G` such that \(C_i = \langle C_{{i+1}}, g_i \rangle\) for \(1 \leq i \leq n\). Note that each polycyclic group has a pcgs, but except for very small groups, a pcgs is not unique.

For each index \(i\) the subsequence of elements \((g_i, \ldots, g_n)\) forms a pcgs of the subgroup \(C_i\). In particular, these *tails* generate the subgroups of the pc series and hence we say that the pc series is *determined* by \(P\).

Let \(r_i\) be the index of \(C_{{i+1}}\) in \(C_i\) which is either a finite positive number or infinity. Then \(r_i\) is the order of \(g_i C_{{i+1}}\) and we call the resulting list of indices the *relative orders* of the pcgs `P`.

Moreover, with respect to a given pcgs \((g_1, \ldots, g_n)\) each element `g` of `G` can be represented in a unique way as a product \(g = g_1^{{e_1}} \cdot g_2^{{e_2}} \cdots g_n^{{e_n}}\) with exponents \(e_i \in \{0, \ldots, r_i-1\}\), if \(r_i\) is finite, and \(e_i \in ℤ\) otherwise. Words of this form are called *normal words* or *words in normal form*. Then the integer vector \([ e_1, \ldots, e_n ]\) is called the *exponent vector* of the element \(g\). Furthermore, the smallest index \(k\) such that \(e_k \neq 0\) is called the *depth* of `g` and \(e_k\) is the *leading exponent* of `g`.

For many applications we have to assume that each of the relative orders \(r_i\) is either a prime or infinity. This is equivalent to saying that there are no trivial factors in the pc series and the finite factors of the pc series are maximal refined. Then we obtain that \(r_i\) is the order of \(g C_{{i+1}}\) for all elements \(g\) in \(C_i \setminus C_{{i+1}}\) and we call \(r_i\) the *relative order* of the element \(g\).

Suppose a group `G` is given; for example, let `G` be a permutation or matrix group. Then we can ask **GAP** to compute a pcgs of this group. If `G` is not polycyclic, the result will be `fail`

.

Note that these methods can only be applied if `G` is not given as finitely presented group. For finitely presented groups one can try to compute a pcgs via the polycyclic quotient methods, see 47.14.

Note also that a pcgs behaves like a list.

`‣ Pcgs` ( G ) | ( attribute ) |

returns a pcgs for the group `G`. If `grp` is not polycyclic it returns `fail`

*and this result is not stored as attribute value*, in particular in this case the filter `HasPcgs`

is *not* set for `G`!

`‣ IsPcgs` ( obj ) | ( category ) |

The category of pcgs.

gap> G := Group((1,2,3,4),(1,2));; gap> p := Pcgs(G); Pcgs([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ]) gap> IsPcgs( p ); true gap> p[1]; (3,4) gap> G := Group((1,2,3,4,5),(1,2));; gap> Pcgs(G); fail

`‣ CanEasilyComputePcgs` ( grp ) | ( filter ) |

This filter indicates whether it is possible to compute a pcgs for `grp` cheaply. Clearly, `grp` must be polycyclic in this case. However, not for every polycyclic group there is a method to compute a pcgs at low costs. This filter is used in the method selection mainly. Note that this filter may change its value from `false`

to `true`

.

gap> G := Group( (1,2,3,4),(1,2) ); Group([ (1,2,3,4), (1,2) ]) gap> CanEasilyComputePcgs(G); false gap> Pcgs(G); Pcgs([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ]) gap> CanEasilyComputePcgs(G); true

In a number of situations it might be useful to supply a pcgs to a group.

Note that the elementary operations for such a pcgs might be rather inefficient, since **GAP** has to use generic methods in this case. It might be helpful to supply the relative orders of the self-defined pcgs as well by `SetRelativeOrder`

. See also `IsPrimeOrdersPcgs`

(45.4-3).

`‣ PcgsByPcSequence` ( fam, pcs ) | ( operation ) |

`‣ PcgsByPcSequenceNC` ( fam, pcs ) | ( operation ) |

constructs a pcgs for the elements family `fam` from the elements in the list `pcs`. The elements must lie in the family `fam`. `PcgsByPcSequence`

and its `NC`

variant will always create a new pcgs which is not induced by any other pcgs (cf. `InducedPcgsByPcSequence`

(45.7-2)).

gap> fam := FamilyObj( (1,2) );; # the family of permutations gap> p := PcgsByPcSequence( fam, [(1,2),(1,2,3)] ); Pcgs([ (1,2), (1,2,3) ]) gap> RelativeOrders(p); [ 2, 3 ] gap> ExponentsOfPcElement( p, (1,3,2) ); [ 0, 2 ]

`‣ RelativeOrders` ( pcgs ) | ( attribute ) |

returns the list of relative orders of the pcgs `pcgs`.

`‣ IsFiniteOrdersPcgs` ( pcgs ) | ( property ) |

tests whether the relative orders of `pcgs` are all finite.

`‣ IsPrimeOrdersPcgs` ( pcgs ) | ( property ) |

tests whether the relative orders of `pcgs` are prime numbers. Many algorithms require a pcgs to have this property. The operation `IsomorphismRefinedPcGroup`

(46.4-8) can be of help here.

`‣ PcSeries` ( pcgs ) | ( attribute ) |

returns the subnormal series determined by `pcgs`.

`‣ GroupOfPcgs` ( pcgs ) | ( attribute ) |

The group generated by `pcgs`.

`‣ OneOfPcgs` ( pcgs ) | ( attribute ) |

The identity of the group generated by `pcgs`.

gap> G := Group( (1,2,3,4),(1,2) );; p := Pcgs(G);; gap> RelativeOrders(p); [ 2, 3, 2, 2 ] gap> IsFiniteOrdersPcgs(p); true gap> IsPrimeOrdersPcgs(p); true gap> PcSeries(p); [ Group([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ]), Group([ (2,4,3), (1,4)(2,3), (1,3)(2,4) ]), Group([ (1,4)(2,3), (1,3)(2,4) ]), Group([ (1,3)(2,4) ]), Group(()) ]

`‣ RelativeOrderOfPcElement` ( pcgs, elm ) | ( operation ) |

The relative order of `elm` with respect to the prime order pcgs `pcgs`.

`‣ ExponentOfPcElement` ( pcgs, elm, pos ) | ( operation ) |

returns the `pos`-th exponent of `elm` with respect to `pcgs`.

`‣ ExponentsOfPcElement` ( pcgs, elm[, posran] ) | ( operation ) |

returns the exponents of `elm` with respect to `pcgs`. The three argument version returns the exponents in the positions given in `posran`.

`‣ DepthOfPcElement` ( pcgs, elm ) | ( operation ) |

returns the depth of the element `elm` with respect to `pcgs`.

`‣ LeadingExponentOfPcElement` ( pcgs, elm ) | ( operation ) |

returns the leading exponent of `elm` with respect to `pcgs`.

`‣ PcElementByExponents` ( pcgs, list ) | ( function ) |

`‣ PcElementByExponentsNC` ( pcgs[, basisind], list ) | ( operation ) |

returns the element corresponding to the exponent vector `list` with respect to `pcgs`. The exponents in `list` must be in the range of permissible exponents for `pcgs`. *It is not guaranteed that PcElementByExponents will reduce the exponents modulo the relative orders*. (You should use the operation

`LinearCombinationPcgs`

(45.5-7) for this purpose.) The `NC`

version does not check that the lengths of the lists fit together and does not check the exponent range.The three argument version gives exponents only w.r.t. the generators in `pcgs` indexed by `basisind`.

`‣ LinearCombinationPcgs` ( pcgs, list[, one] ) | ( function ) |

returns the product \(\prod_i \textit{pcgs}[i]^{{\textit{list}[i]}}\). In contrast to `PcElementByExponents`

(45.5-6) this permits negative exponents. `pcgs` might be a list of group elements. In this case, an appropriate identity element `one` must be given. `list` can be empty.

gap> G := Group( (1,2,3,4),(1,2) );; P := Pcgs(G);; gap> g := PcElementByExponents(P, [0,1,1,1]); (1,2,3) gap> ExponentsOfPcElement(P, g); [ 0, 1, 1, 1 ]

`‣ SiftedPcElement` ( pcgs, elm ) | ( operation ) |

sifts `elm` through `pcgs`, reducing it if the depth is the same as the depth of one of the generators in `pcgs`. Thus the identity is returned if `elm` lies in the group generated by `pcgs`. `pcgs` must be an induced pcgs (see section 45.7) and `elm` must lie in the span of the parent of `pcgs`.

`‣ CanonicalPcElement` ( ipcgs, elm ) | ( operation ) |

reduces `elm` at the induces pcgs `ipcgs` such that the exponents of the reduced result `r` are zero at the depths for which there are generators in `ipcgs`. Elements, whose quotient lies in the group generated by `ipcgs` yield the same canonical element.

`‣ ReducedPcElement` ( pcgs, x, y ) | ( operation ) |

reduces the element `x` by dividing off (from the left) a power of `y` such that the leading coefficient of the result with respect to `pcgs` becomes zero. The elements `x` and `y` therefore have to have the same depth.

`‣ CleanedTailPcElement` ( pcgs, elm, dep ) | ( operation ) |

returns an element in the span of `pcgs` whose exponents for indices \(1\) to \(\textit{dep}-1\) with respect to `pcgs` are the same as those of `elm`, the remaining exponents are undefined. This can be used to obtain more "simple" elements if only representatives in a factor are required, see 45.9.

The difference to `HeadPcElementByNumber`

(45.5-12) is that this function is guaranteed to zero out trailing coefficients while `CleanedTailPcElement`

will only do this if it can be done cheaply.

`‣ HeadPcElementByNumber` ( pcgs, elm, dep ) | ( operation ) |

returns an element in the span of `pcgs` whose exponents for indices \(1\) to `dep`\(-1\) with respect to `pcgs` are the same as those of `elm`, the remaining exponents are zero. This can be used to obtain more "simple" elements if only representatives in a factor are required.

There are certain products of elements whose exponents are used often within algorithms, and which might be obtained more easily than by computing the product first and to obtain its exponents afterwards. The operations in this section provide a way to obtain such exponent vectors directly.

(The circumstances under which these operations give a speedup depend very much on the pcgs and the representation of elements that is used. So the following operations are not guaranteed to give a speedup in every case, however the default methods are not slower than to compute the exponents of a product and thus these operations should *always* be used if applicable.)

The second class are exponents of products of the generators which make up the pcgs. If the pcgs used is a family pcgs (see `FamilyPcgs`

(46.1-1)) then these exponents can be looked up and do not need to be computed.

`‣ ExponentsConjugateLayer` ( mpcgs, elm, e ) | ( operation ) |

Computes the exponents of `elm``^`

`e` with respect to `mpcgs`; `elm` must be in the span of `mpcgs`, `e` a pc element in the span of the parent pcgs of `mpcgs` and `mpcgs` must be the modulo pcgs for an abelian layer. (This is the usual case when acting on a chief factor). In this case if `mpcgs` is induced by the family pcgs (see section 45.7), the exponents can be computed directly by looking up exponents without having to compute in the group and having to collect a potential tail.

`‣ ExponentsOfRelativePower` ( pcgs, i ) | ( operation ) |

For \(p = \textit{pcgs}[\textit{i}]\) this function returns the exponent vector with respect to `pcgs` of the element \(p^e\) where \(e\) is the relative order of `p` in `pcgs`. For the family pcgs or pcgs induced by it (see section 45.7), this might be faster than computing the element and computing its exponent vector.

`‣ ExponentsOfConjugate` ( pcgs, i, j ) | ( operation ) |

returns the exponents of

with respect to `pcgs`[`i`]^`pcgs`[`j`]`pcgs`. For the family pcgs or pcgs induced by it (see section 45.7), this might be faster than computing the element and computing its exponent vector.

`‣ ExponentsOfCommutator` ( pcgs, i, j ) | ( operation ) |

returns the exponents of the commutator `Comm( `

\(\textit{pcgs}[\textit{i}], \textit{pcgs}[\textit{j}]\)` )`

with respect to `pcgs`. For the family pcgs or pcgs induced by it, (see section 45.7), this might be faster than computing the element and computing its exponent vector.

Let `U` be a subgroup of `G` and let `P` be a pcgs of `G` as above such that `P` determines the subnormal series \(G = C_1 > \ldots > C_{{n+1}} = \{ 1 \}\). Then the series of subgroups \(U \cap C_i\) is a subnormal series of `U` with cyclic or trivial factors. Hence, if we choose an element \(u_{{i_j}} \in (U \cap C_{{i_j}}) \setminus (U \cap C_{{i_j+1}})\) whenever this factor is non-trivial, then we obtain a pcgs \(Q = (u_{{i_1}}, \ldots, u_{{i_m}})\) of \(U\). We say that \(Q\) is an *induced pcgs* with respect to `P`. The pcgs `P` is the *parent pcgs* to the induced pcgs `Q`.

Note that the pcgs \(Q\) is induced with respect to `P` if and only if the matrix of exponent vectors of the elements \(u_{{i_j}}\) with respect to `P` is in upper triangular form. Thus \(Q\) is not unique in general.

In particular, the elements of an induced pcgs do *not necessarily* have leading coefficient 1 relative to the inducing pcgs. The attribute `LeadCoeffsIGS`

(45.7-7) holds the leading coefficients in case they have to be renormed in an algorithm.

Each induced pcgs is a pcgs and hence allows all elementary operations for pcgs. On the other hand each pcgs could be transformed into an induced pcgs for the group defined by the pcgs, but note that an arbitrary pcgs is in general not an induced pcgs for technical reasons.

An induced pcgs is "compatible" with its parent, see `ParentPcgs`

(45.7-3).

In [LNS84] a "non-commutative Gauss" algorithm is described to compute an induced pcgs of a subgroup `U` from a generating set of `U`. For calling this in **GAP**, see 45.7-4 to 45.7-8.

To create a subgroup generated by an induced pcgs such that the induced pcgs gets stored automatically, use `SubgroupByPcgs`

(45.7-9).

`‣ IsInducedPcgs` ( pcgs ) | ( category ) |

The category of induced pcgs. This a subcategory of pcgs.

`‣ InducedPcgsByPcSequence` ( pcgs, pcs ) | ( operation ) |

`‣ InducedPcgsByPcSequenceNC` ( pcgs, pcs[, depths] ) | ( operation ) |

If `pcs` is a list of elements that form an induced pcgs with respect to `pcgs` this operation returns an induced pcgs with these elements.

In the third version, the depths of `pcs` with respect to `pcgs` can be given (they are computed anew otherwise).

`‣ ParentPcgs` ( pcgs ) | ( attribute ) |

returns the pcgs by which `pcgs` was induced. If `pcgs` was not induced, it simply returns `pcgs`.

gap> G := Group( (1,2,3,4),(1,2) );; gap> P := Pcgs(G);; gap> K := InducedPcgsByPcSequence( P, [(1,2,3,4),(1,3)(2,4)] ); Pcgs([ (1,2,3,4), (1,3)(2,4) ]) gap> ParentPcgs( K ); Pcgs([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ]) gap> IsInducedPcgs( K ); true

`‣ InducedPcgs` ( pcgs, grp ) | ( function ) |

computes a pcgs for `grp` which is induced by `pcgs`. If `pcgs` has a parent pcgs, then the result is induced with respect to this parent pcgs.

`InducedPcgs`

is a wrapper function only. Therefore, methods for computing an induced pcgs should be installed for the operation `InducedPcgsOp`

.

`‣ InducedPcgsByGenerators` ( pcgs, gens ) | ( operation ) |

`‣ InducedPcgsByGeneratorsNC` ( pcgs, gens ) | ( operation ) |

returns an induced pcgs with respect to `pcgs` for the subgroup generated by `gens`.

`‣ InducedPcgsByPcSequenceAndGenerators` ( pcgs, ind, gens ) | ( operation ) |

returns an induced pcgs with respect to `pcgs` of the subgroup generated by `ind` and `gens`. Here `ind` must be an induced pcgs with respect to `pcgs` (or a list of group elements that form such an igs) and it will be used as initial sequence for the computation.

gap> G := Group( (1,2,3,4),(1,2) );; P := Pcgs(G);; gap> I := InducedPcgsByGenerators( P, [(1,2,3,4)] ); Pcgs([ (1,2,3,4), (1,3)(2,4) ]) gap> J := InducedPcgsByPcSequenceAndGenerators( P, I, [(1,2)] ); Pcgs([ (1,2,3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ])

`‣ LeadCoeffsIGS` ( igs ) | ( attribute ) |

This attribute is used to store leading coefficients with respect to the parent pcgs. the `i`-th entry –if bound– is the leading exponent of the element of `igs` that has depth `i` in the parent. (It cannot be assigned to a component in the object created by `InducedPcgsByPcSequenceNC`

(45.7-2) as the permutation group methods call it from within the postprocessing, before this postprocessing however no coefficients may be computed.)

`‣ ExtendedPcgs` ( N, gens ) | ( operation ) |

extends the pcgs `N` (induced w.r.t. `home`) to a new induced pcgs by prepending `gens`. No checks are performed that this really yields an induced pcgs.

`‣ SubgroupByPcgs` ( G, pcgs ) | ( operation ) |

returns a subgroup of `G` generated by the elements of `pcgs`.

The induced pcgs `Q` of `U` is called *canonical* if the matrix of exponent vectors contains normed vectors only and above each leading entry in the matrix there are 0's only. The canonical pcgs of `U` with respect to `P` is unique and hence such pcgs can be used to compare subgroups.

`‣ IsCanonicalPcgs` ( pcgs ) | ( property ) |

An induced pcgs is canonical if the matrix of the exponent vectors of the elements of `pcgs` with respect to the `ParentPcgs`

(45.7-3) value of `pcgs` is in Hermite normal form (see [LNS84]). While a subgroup can have various induced pcgs with respect to a parent pcgs a canonical pcgs is unique.

`‣ CanonicalPcgs` ( pcgs ) | ( attribute ) |

returns the canonical pcgs corresponding to the induced pcgs `pcgs`.

gap> G := Group((1,2,3,4),(5,6,7)); Group([ (1,2,3,4), (5,6,7) ]) gap> P := Pcgs(G); Pcgs([ (5,6,7), (1,2,3,4), (1,3)(2,4) ]) gap> I := InducedPcgsByPcSequence(P, [(5,6,7)*(1,3)(2,4),(1,3)(2,4)] ); Pcgs([ (1,3)(2,4)(5,6,7), (1,3)(2,4) ]) gap> CanonicalPcgs(I); Pcgs([ (5,6,7), (1,3)(2,4) ])

Let `N` be a normal subgroup of `G` such that `G/N` is polycyclic with pcgs \((h_1 N, \ldots, h_r N)\). Then we call the sequence of preimages \((h_1, \ldots h_r)\) a *modulo pcgs* of `G/N`. `G` is called the *numerator* of the modulo pcgs and `N` is the *denominator* of the modulo pcgs.

Modulo pcgs are often used to facilitate efficient computations with factor groups, since they allow computations with factor groups without formally defining the factor group at all.

All elementary operations of pcgs, see Sections 45.4 and 45.5, apply to modulo pcgs as well. However, it is in general not possible to compute induced pcgs with respect to a modulo pcgs.

Two more elementary operations for modulo pcgs are `NumeratorOfModuloPcgs`

(45.9-3) and `DenominatorOfModuloPcgs`

(45.9-4).

`‣ ModuloPcgs` ( G, N ) | ( operation ) |

returns a modulo pcgs for the factor \(\textit{G}/\textit{N}\) which must be solvable, while `N` may be non-solvable. `ModuloPcgs`

will return *a* pcgs for the factor, there is no guarantee that it will be "compatible" with any other pcgs. If this is required, the `mod`

operator must be used on induced pcgs, see `\mod`

(45.9-5).

`‣ IsModuloPcgs` ( obj ) | ( category ) |

The category of modulo pcgs. Note that each pcgs is a modulo pcgs for the trivial subgroup.

`‣ NumeratorOfModuloPcgs` ( pcgs ) | ( attribute ) |

returns a generating set for the numerator of the modulo pcgs `pcgs`.

`‣ DenominatorOfModuloPcgs` ( pcgs ) | ( attribute ) |

returns a generating set for the denominator of the modulo pcgs `pcgs`.

gap> G := Group( (1,2,3,4,5),(1,2) ); Group([ (1,2,3,4,5), (1,2) ]) gap> P := ModuloPcgs(G, DerivedSubgroup(G) ); Pcgs([ (4,5) ]) gap> NumeratorOfModuloPcgs(P); [ (1,2,3,4,5), (1,2) ] gap> DenominatorOfModuloPcgs(P); [ (1,3,2), (1,4,3), (2,5,4) ] gap> RelativeOrders(P); [ 2 ] gap> ExponentsOfPcElement( P, (1,2,3,4,5) ); [ 0 ] gap> ExponentsOfPcElement( P, (4,5) ); [ 1 ]

`45.9-5 \mod`

`‣ \mod` ( P, I ) | ( method ) |

Modulo Pcgs can also be built from compatible induced pcgs. Let \(G\) be a group with pcgs `P` and let `I` be an induced pcgs of a normal subgroup \(N\) of \(G\). (Respectively: `P` and `I` are both induced with respect to the *same* Pcgs.) Then we can compute a modulo pcgs of \(G\) mod \(N\) by

`P` `mod`

`I`

Note that in this case we obtain the advantage that the values of `NumeratorOfModuloPcgs`

(45.9-3) and `DenominatorOfModuloPcgs`

(45.9-4) are just `P` and `I`, respectively, and hence are unique.

The resulting modulo pcgs will consist of a subset of `P` and will be "compatible" with `P` (or its parent).

gap> G := Group((1,2,3,4));; gap> P := Pcgs(G); Pcgs([ (1,2,3,4), (1,3)(2,4) ]) gap> I := InducedPcgsByGenerators(P, [(1,3)(2,4)]); Pcgs([ (1,3)(2,4) ]) gap> M := P mod I; [ (1,2,3,4) ] gap> NumeratorOfModuloPcgs(M); Pcgs([ (1,2,3,4), (1,3)(2,4) ]) gap> DenominatorOfModuloPcgs(M); Pcgs([ (1,3)(2,4) ])

`‣ CorrespondingGeneratorsByModuloPcgs` ( mpcgs, imgs ) | ( function ) |

Let `mpcgs` be a modulo pcgs for a factor of a group \(G\) and let \(U\) be a subgroup of \(G\) generated by `imgs` such that \(U\) covers the factor for the modulo pcgs. Then this function computes elements in \(U\) corresponding to the generators of the modulo pcgs.

Note that the computation of induced generating sets is not possible for some modulo pcgs.

`‣ CanonicalPcgsByGeneratorsWithImages` ( pcgs, gens, imgs ) | ( operation ) |

computes a canonical, `pcgs`-induced pcgs for the span of `gens` and simultaneously does the same transformations on `imgs`, preserving thus a correspondence between `gens` and `imgs`. This operation is used to represent homomorphisms from a pc group.

If substantial calculations are done in a factor it might be worth still to construct the factor group in its own representation (for example by calling `PcGroupWithPcgs`

(46.5-1) on a modulo pcgs.

The following functions are intended for working with factor groups obtained by factoring out the tail of a pcgs. They provide a way to map elements or induced pcgs quickly in the factor (respectively to take preimages) without the need to construct a homomorphism.

The setup is always a pcgs `pcgs` of `G` and a pcgs `fpcgs` of a factor group \(H = \textit{G}/\textit{N}\) which corresponds to a head of `pcgs`.

No tests for validity of the input are performed.

`‣ ProjectedPcElement` ( pcgs, fpcgs, elm ) | ( function ) |

returns the image in `H` of an element `elm` of `G`.

`‣ ProjectedInducedPcgs` ( pcgs, fpcgs, ipcgs ) | ( function ) |

`ipcgs` must be an induced pcgs with respect to `pcgs`. This operation returns an induced pcgs with respect to `fpcgs` consisting of the nontrivial images of `ipcgs`.

`‣ LiftedPcElement` ( pcgs, fpcgs, elm ) | ( function ) |

returns a preimage in `G` of an element `elm` of `H`.

`‣ LiftedInducedPcgs` ( pcgs, fpcgs, ipcgs, ker ) | ( function ) |

`ipcgs` must be an induced pcgs with respect to `fpcgs`. This operation returns an induced pcgs with respect to `pcgs` consisting of the preimages of `ipcgs`, appended by the elements in `ker` (assuming there is a bijection of `pcgs` mod `ker` to `fpcgs`). `ker` might be a simple element list.

By definition, a pcgs determines a pc series of its underlying group. However, in many applications it will be necessary that this pc series refines a normal series with certain properties; for example, a normal series with abelian factors.

There are functions in **GAP** to compute a pcgs through a normal series with elementary abelian factors, a central series or the lower p-central series. See also Section 45.13 for a more explicit possibility.

`‣ IsPcgsElementaryAbelianSeries` ( pcgs ) | ( property ) |

returns `true`

if the pcgs `pcgs` refines an elementary abelian series. `IndicesEANormalSteps`

(45.11-3) then gives the indices in the Pcgs, at which the subgroups of this series start.

`‣ PcgsElementaryAbelianSeries` ( G ) | ( attribute ) |

`‣ PcgsElementaryAbelianSeries` ( list ) | ( attribute ) |

computes a pcgs for `G` that refines an elementary abelian series. `IndicesEANormalSteps`

(45.11-3) gives the indices in the pcgs, at which the normal subgroups of this series start. The second variant returns a pcgs that runs through the normal subgroups in the list `list`.

`‣ IndicesEANormalSteps` ( pcgs ) | ( attribute ) |

`‣ IndicesEANormalStepsBounded` ( pcgs, bound ) | ( function ) |

Let `pcgs` be a pcgs obtained as corresponding to a series of normal subgroups with elementary abelian factors (for example from calling `PcgsElementaryAbelianSeries`

(45.11-2)) Then `IndicesEANormalSteps`

returns a sorted list of integers, indicating the tails of `pcgs` which generate these normal subgroup of `G`. If \(i\) is an element of this list, \((g_i, \ldots, g_n)\) is a normal subgroup of `G`. The list always starts with \(1\) and ends with \(n+1\). (These indices form *one* series with elementary abelian subfactors, not necessarily the most refined one.)

The attribute `EANormalSeriesByPcgs`

(45.11-4) returns the actual series of subgroups.

For arbitrary pcgs not obtained as belonging to a special series such a set of indices not necessarily exists, and `IndicesEANormalSteps`

is not guaranteed to work in this situation.

Typically, `IndicesEANormalSteps`

is set by `PcgsElementaryAbelianSeries`

(45.11-2).

The variant `IndicesEANormalStepsBounded`

will aim to ensure that no factor will be larger than the given bound.

`‣ EANormalSeriesByPcgs` ( pcgs ) | ( attribute ) |

Let `pcgs` be a pcgs obtained as corresponding to a series of normal subgroups with elementary abelian factors (for example from calling `PcgsElementaryAbelianSeries`

(45.11-2)). This attribute returns the actual series of normal subgroups, corresponding to `IndicesEANormalSteps`

(45.11-3).

`‣ IsPcgsCentralSeries` ( pcgs ) | ( property ) |

returns `true`

if the pcgs `pcgs` refines an central elementary abelian series. `IndicesCentralNormalSteps`

(45.11-7) then gives the indices in the pcgs, at which the subgroups of this series start.

`‣ PcgsCentralSeries` ( G ) | ( attribute ) |

computes a pcgs for `G` that refines a central elementary abelian series. `IndicesCentralNormalSteps`

(45.11-7) gives the indices in the pcgs, at which the normal subgroups of this series start.

`‣ IndicesCentralNormalSteps` ( pcgs ) | ( attribute ) |

Let `pcgs` be a pcgs obtained as corresponding to a series of normal subgroups with central elementary abelian factors (for example from calling `PcgsCentralSeries`

(45.11-6)). Then `IndicesCentralNormalSteps`

returns a sorted list of integers, indicating the tails of `pcgs` which generate these normal subgroups of `G`. If \(i\) is an element of this list, \((g_i, \ldots, g_n)\) is a normal subgroup of `G`. The list always starts with \(1\) and ends with \(n+1\). (These indices form *one* series with central elementary abelian subfactors, not necessarily the most refined one.)

The attribute `CentralNormalSeriesByPcgs`

(45.11-8) returns the actual series of subgroups.

For arbitrary pcgs not obtained as belonging to a special series such a set of indices not necessarily exists, and `IndicesCentralNormalSteps`

is not guaranteed to work in this situation.

Typically, `IndicesCentralNormalSteps`

is set by `PcgsCentralSeries`

(45.11-6).

`‣ CentralNormalSeriesByPcgs` ( pcgs ) | ( attribute ) |

Let `pcgs` be a pcgs obtained as corresponding to a series of normal subgroups with central elementary abelian factors (for example from calling `PcgsCentralSeries`

(45.11-6)). This attribute returns the actual series of normal subgroups, corresponding to `IndicesCentralNormalSteps`

(45.11-7).

`‣ IsPcgsPCentralSeriesPGroup` ( pcgs ) | ( property ) |

returns `true`

if the pcgs `pcgs` refines a \(p\)-central elementary abelian series for a \(p\)-group. `IndicesPCentralNormalStepsPGroup`

(45.11-11) then gives the indices in the pcgs, at which the subgroups of this series start.

`‣ PcgsPCentralSeriesPGroup` ( G ) | ( attribute ) |

computes a pcgs for the \(p\)-group `G` that refines a \(p\)-central elementary abelian series. `IndicesPCentralNormalStepsPGroup`

(45.11-11) gives the indices in the pcgs, at which the normal subgroups of this series start.

`‣ IndicesPCentralNormalStepsPGroup` ( pcgs ) | ( attribute ) |

Let `pcgs` be a pcgs obtained as corresponding to a series of normal subgroups with \(p\)-central elementary abelian factors (for example from calling `PcgsPCentralSeriesPGroup`

(45.11-10)). Then `IndicesPCentralNormalStepsPGroup`

returns a sorted list of integers, indicating the tails of `pcgs` which generate these normal subgroups of `G`. If \(i\) is an element of this list, \((g_i, \ldots, g_n)\) is a normal subgroup of `G`. The list always starts with \(1\) and ends with \(n+1\). (These indices form *one* series with central elementary abelian subfactors, not necessarily the most refined one.)

The attribute `PCentralNormalSeriesByPcgsPGroup`

(45.11-12) returns the actual series of subgroups.

For arbitrary pcgs not obtained as belonging to a special series such a set of indices not necessarily exists, and `IndicesPCentralNormalStepsPGroup`

is not guaranteed to work in this situation.

Typically, `IndicesPCentralNormalStepsPGroup`

is set by `PcgsPCentralSeriesPGroup`

(45.11-10).

`‣ PCentralNormalSeriesByPcgsPGroup` ( pcgs ) | ( attribute ) |

Let `pcgs` be a pcgs obtained as corresponding to a series of normal subgroups with \(p\)-central elementary abelian factors (for example from calling `PcgsPCentralSeriesPGroup`

(45.11-10)). This attribute returns the actual series of normal subgroups, corresponding to `IndicesPCentralNormalStepsPGroup`

(45.11-11).

`‣ IsPcgsChiefSeries` ( pcgs ) | ( property ) |

returns `true`

if the pcgs `pcgs` refines a chief series. `IndicesChiefNormalSteps`

(45.11-15) then gives the indices in the pcgs, at which the subgroups of this series start.

`‣ PcgsChiefSeries` ( G ) | ( attribute ) |

computes a pcgs for `G` that refines a chief series. `IndicesChiefNormalSteps`

(45.11-15) gives the indices in the pcgs, at which the normal subgroups of this series start.

`‣ IndicesChiefNormalSteps` ( pcgs ) | ( attribute ) |

Let `pcgs` be a pcgs obtained as corresponding to a chief series for example from calling `PcgsChiefSeries`

(45.11-14)). Then `IndicesChiefNormalSteps`

returns a sorted list of integers, indicating the tails of `pcgs` which generate these normal subgroups of `G`. If \(i\) is an element of this list, \((g_i, \ldots, g_n)\) is a normal subgroup of `G`. The list always starts with \(1\) and ends with \(n+1\). (These indices form *one* series with elementary abelian subfactors, not necessarily the most refined one.)

The attribute `ChiefNormalSeriesByPcgs`

(45.11-16) returns the actual series of subgroups.

For arbitrary pcgs not obtained as belonging to a special series such a set of indices not necessarily exists, and `IndicesChiefNormalSteps`

is not guaranteed to work in this situation.

Typically, `IndicesChiefNormalSteps`

is set by `PcgsChiefSeries`

(45.11-14).

`‣ ChiefNormalSeriesByPcgs` ( pcgs ) | ( attribute ) |

Let `pcgs` be a pcgs obtained as corresponding to a chief series (for example from calling `PcgsChiefSeries`

(45.11-14)). This attribute returns the actual series of normal subgroups, corresponding to `IndicesChiefNormalSteps`

(45.11-15).

gap> g:=Group((1,2,3,4),(1,2));; gap> p:=PcgsElementaryAbelianSeries(g); Pcgs([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ]) gap> IndicesEANormalSteps(p); [ 1, 2, 3, 5 ] gap> g:=Group((1,2,3,4),(1,5)(2,6)(3,7)(4,8));; gap> p:=PcgsCentralSeries(g); Pcgs([ (1,5)(2,6)(3,7)(4,8), (5,6,7,8), (5,7)(6,8), (1,4,3,2)(5,6,7,8), (1,3)(2,4)(5,7)(6,8) ]) gap> IndicesCentralNormalSteps(p); [ 1, 2, 4, 5, 6 ] gap> q:=PcgsPCentralSeriesPGroup(g); Pcgs([ (1,5)(2,6)(3,7)(4,8), (5,6,7,8), (5,7)(6,8), (1,4,3,2)(5,6,7,8), (1,3)(2,4)(5,7)(6,8) ]) gap> IndicesPCentralNormalStepsPGroup(q); [ 1, 3, 5, 6 ]

`‣ IndicesNormalSteps` ( pcgs ) | ( attribute ) |

returns the indices of *all* steps in the pc series, which are normal in the group defined by the pcgs.

(In general, this function yields a slower performance than the more specialized index functions for elementary abelian series etc.)

`‣ NormalSeriesByPcgs` ( pcgs ) | ( attribute ) |

returns the subgroups the pc series, which are normal in the group defined by the pcgs.

(In general, this function yields a slower performance than the more specialized index functions for elementary abelian series etc.)

`‣ SumFactorizationFunctionPcgs` ( parentpcgs, n, u, kerpcgs ) | ( operation ) |

computes the sum and intersection of the lists `n` and `u` whose elements form modulo pcgs induced by `parentpcgs` for two subgroups modulo a kernel given by `kerpcgs`. If `kerpcgs` is a tail if the `parent-pcgs` it is sufficient to give the starting depth, this can be more efficient than to construct an explicit pcgs. The factor group modulo `kerpcgs` generated by `n` must be elementary abelian and normal under `u`.

The function returns a record with components

`sum`

elements that form a modulo pcgs for the span of both subgroups.

`intersection`

elements that form a modulo pcgs for the intersection of both subgroups.

`factorization`

a function that returns for an element

`x`in the span of`sum`

a record with components`u`

and`n`

that give its decomposition.

The record components `sum`

and `intersection`

are *not* pcgs but only lists of pc elements (to avoid unnecessary creation of induced pcgs).

In short, a special pcgs is a pcgs which has particularly nice properties, for example it always refines an elementary abelian series, for \(p\)-groups it even refines a central series. These nice properties permit particularly efficient algorithms.

Let `G` be a finite polycyclic group. A *special pcgs* of `G` is a pcgs which is closely related to a Hall system and the maximal subgroups of `G`. These pcgs have been introduced by C. R. Leedham-Green who also gave an algorithm to compute them. Improvements to this algorithm are due to Bettina Eick. For a more detailed account of their definition the reader is referred to [Eic97]

To introduce the definition of special pcgs we first need to define the *LG-series* and *head complements* of a finite polycyclic group `G`. Let \(G = G_1 > G_2 > \ldots G_m > G_{{m+1}} = \{ 1 \}\) be the lower nilpotent series of \(G\); that is, \(G_i\) is the smallest normal subgroup of \(G_{{i-1}}\) with nilpotent factor. To obtain the LG-series of `G` we need to refine this series. Thus consider a factor \(F_i := G_i / G_{{i+1}}\). Since \(F_i\) is finite nilpotent, it is a direct product of its Sylow subgroups \(F_i = P_{{i,1}} \cdots P_{{i,r_i}}\). For each Sylow \(p_j\)-subgroup \(P_{{i,j}}\) we can consider its lower \(p_j\)-central series. To obtain a characteristic central series with elementary abelian factors of \(F_i\) we loop over its Sylow subgroups. Each time we consider \(P_{{i,j}}\) in this process we take the next step of its lower \(p_j\)-central series into the series of \(F_i\). If there is no next step, then we just skip the consideration of \(P_{{i,j}}\). Note that the second term of the lower \(p\)-central series of a \(p\)-group is in fact its Frattini subgroup. Thus the Frattini subgroup of \(F_i\) is contained in the computed series of this group. We denote the Frattini subgroup of \(F_i = G_i / G_{{i+1}}\) by \(G_i^* / G_{{i+1}}\).

The factors \(G_i / G_i^*\) are called the heads of \(G\), while the (possibly trivial) factors \(G_i^* / G_{{i+1}}\) are the tails of \(G\). A head complement of \(G\) is a subgroup \(U\) of \(G\) such that \(U / G_i^*\) is a complement to the head \(G_i / G_i^*\) in \(G / G_i^*\) for some \(i\).

Now we are able to define a special pcgs of `G`. It is a pcgs of `G` with three additional properties. First, the pc series determined by the pcgs refines the LG-series of `G`. Second, a special pcgs *exhibits* a Hall system of the group `G`; that is, for each set of primes \(\pi\) the elements of the pcgs with relative order in \(\pi\) form a pcgs of a Hall \(\pi\)-subgroup in a Hall system of `G`. Third, a special pcgs exhibits a head complement for each head of `G`.

To record information about the LG-series with the special pcgs we define the *LGWeights* of the special pcgs. These weights are a list which contains a weight \(w\) for each elements \(g\) of the special pcgs. Such a weight \(w\) represents the smallest subgroup of the LG-series containing \(g\).

Since the LG-series is defined in terms of the lower nilpotent series, Sylow subgroups of the factors and lower \(p\)-central series of the Sylow subgroup, the weight \(w\) is a triple. More precisely, \(g\) is contained in the \(w[1]\)th term \(U\) of the lower nilpotent series of `G`, but not in the next smaller one \(V\). Then \(w[3]\) is a prime such that \(g V\) is contained in the Sylow \(w[3]\)-subgroup \(P/V\) of \(U/V\). Moreover, \(gV\) is contained in the \(w[2]\)th term of the lower \(p\)-central series of \(P/V\).

There are two more attributes of a special pcgs containing information about the LG-series: the list *LGLayers* and the list *LGFirst*. The list of layers corresponds to the elements of the special pcgs and denotes the layer of the LG-series in which an element lies. The list LGFirst corresponds to the LG-series and gives the number of the first element in the special pcgs of the corresponding subgroup.

`‣ IsSpecialPcgs` ( obj ) | ( property ) |

tests whether `obj` is a special pcgs.

`‣ SpecialPcgs` ( pcgs ) | ( attribute ) |

`‣ SpecialPcgs` ( G ) | ( attribute ) |

computes a special pcgs for the group defined by `pcgs` or for `G`.

`‣ LGWeights` ( pcgs ) | ( attribute ) |

returns the LGWeights of the special pcgs `pcgs`.

`‣ LGLayers` ( pcgs ) | ( attribute ) |

returns the layers of the special pcgs `pcgs`.

`‣ LGFirst` ( pcgs ) | ( attribute ) |

returns the first indices for each layer of the special pcgs `pcgs`.

`‣ LGLength` ( G ) | ( attribute ) |

returns the length of the LG-series of the group `G`, if `G` is solvable, and `fail`

otherwise.

gap> G := SmallGroup( 96, 220 ); <pc group of size 96 with 6 generators> gap> spec := SpecialPcgs( G ); Pcgs([ f1, f2, f3, f4, f5, f6 ]) gap> LGWeights(spec); [ [ 1, 1, 2 ], [ 1, 1, 2 ], [ 1, 1, 2 ], [ 1, 1, 2 ], [ 1, 1, 3 ], [ 1, 2, 2 ] ] gap> LGLayers(spec); [ 1, 1, 1, 1, 2, 3 ] gap> LGFirst(spec); [ 1, 5, 6, 7 ] gap> LGLength( G ); 3 gap> p := SpecialPcgs( Pcgs( SmallGroup( 96, 120 ) ) ); Pcgs([ f1, f2, f3, f4, f5, f6 ]) gap> LGWeights(p); [ [ 1, 1, 2 ], [ 1, 1, 2 ], [ 1, 1, 2 ], [ 1, 2, 2 ], [ 1, 3, 2 ], [ 2, 1, 3 ] ]

Thus the first group, `SmallGroup(96, 220)`

, has a lower nilpotent series of length \(1\); that is, the group is nilpotent. It is a direct product of its Sylow subgroups. Moreover the Sylow \(2\)-subgroup is generated by the elements `f1, f2, f3, f4, f6`

, and the Sylow \(3\)-subgroup is generated by `f5`

. The lower \(2\)-central series of the Sylow \(2\)-subgroup has length \(2\) and the second subgroup in this series is generated by `f6`

.

The second group, `SmallGroup(96, 120)`

, has a lower nilpotent series of length \(2\) and hence is not nilpotent. The second subgroup in this series is just the Sylow \(3\)-subgroup and it is generated by `f6`

. The subgroup generated by `f1`

, \(\ldots\), `f5`

is a Sylow \(2\)-subgroup of the group and also a head complement to the second head of the group. Its lower \(2\)-central series has length \(2\).

In this example the `FamilyPcgs`

(46.1-1) value of the groups used was a special pcgs, but this is not necessarily the case. For performance reasons it can be worth to enforce this, see `IsomorphismSpecialPcGroup`

(46.5-3).

`‣ IsInducedPcgsWrtSpecialPcgs` ( pcgs ) | ( property ) |

tests whether `pcgs` is induced with respect to a special pcgs.

`‣ InducedPcgsWrtSpecialPcgs` ( G ) | ( attribute ) |

computes an induced pcgs with respect to the special pcgs of the parent of `G`.

`InducedPcgsWrtSpecialPcgs`

will return a pcgs induced by *a* special pcgs (which might differ from the one you had in mind). If you need an induced pcgs compatible with a *given* special pcgs use `InducedPcgs`

(45.7-4) for this special pcgs.

When working with a polycyclic group, one often needs to compute matrix operations of the group on a factor of the group. For this purpose there are the functions described in 45.14-1 to 45.14-3.

In certain situations, for example within the computation of conjugacy classes of finite soluble groups as described in [MN89], affine actions of groups are required. For this purpose we introduce the functions `AffineAction`

(45.14-4) and `AffineActionLayer`

(45.14-5).

`‣ VectorSpaceByPcgsOfElementaryAbelianGroup` ( mpcgs, fld ) | ( function ) |

returns the vector space over `fld` corresponding to the modulo pcgs `mpcgs`. Note that `mpcgs` has to define an elementary abelian \(p\)-group where \(p\) is the characteristic of `fld`.

`‣ LinearAction` ( gens, basisvectors, linear ) | ( operation ) |

`‣ LinearOperation` ( gens, basisvectors, linear ) | ( operation ) |

returns a list of matrices, one for each element of `gens`, which corresponds to the matrix action of the elements in `gens` on the basis `basisvectors` via `linear`.

`‣ LinearActionLayer` ( G, gens, pcgs ) | ( function ) |

`‣ LinearOperationLayer` ( G, gens, pcgs ) | ( function ) |

returns a list of matrices, one for each element of `gens`, which corresponds to the matrix action of `G` on the vector space corresponding to the modulo pcgs `pcgs`.

`‣ AffineAction` ( gens, basisvectors, linear, transl ) | ( operation ) |

return a list of matrices, one for each element of `gens`, which corresponds to the affine action of the elements in `gens` on the basis `basisvectors` via `linear` with translation `transl`.

`‣ AffineActionLayer` ( G, gens, pcgs, transl ) | ( function ) |

returns a list of matrices, one for each element of `gens`, which corresponds to the affine action of `G` on the vector space corresponding to the modulo pcgs `pcgs` with translation `transl`.

gap> G := SmallGroup( 96, 51 ); <pc group of size 96 with 6 generators> gap> spec := SpecialPcgs( G ); Pcgs([ f1, f2, f3, f4, f5, f6 ]) gap> LGWeights( spec ); [ [ 1, 1, 2 ], [ 1, 1, 2 ], [ 1, 1, 3 ], [ 1, 2, 2 ], [ 1, 2, 2 ], [ 1, 3, 2 ] ] gap> mpcgs := InducedPcgsByPcSequence( spec, spec{[4,5,6]} ); Pcgs([ f4, f5, f6 ]) gap> npcgs := InducedPcgsByPcSequence( spec, spec{[6]} ); Pcgs([ f6 ]) gap> modu := mpcgs mod npcgs; [ f4, f5 ] gap> mat:=LinearActionLayer( G, spec{[1,2,3]}, modu ); [ <an immutable 2x2 matrix over GF2>, <an immutable 2x2 matrix over GF2>, <an immutable 2x2 matrix over GF2> ] gap> Print( mat, "\n" ); [ [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ], [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ], [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] ]

If a pcgs `pcgs` is known for a group `G`, then orbits and stabilizers can be computed by a special method which is particularly efficient. Note that within this function only the elements in `pcgs` and the relative orders of `pcgs` are needed. Hence this function works effectively even if the elementary operations for `pcgs` are slow.

`‣ StabilizerPcgs` ( pcgs, pnt[, acts][, act] ) | ( function ) |

computes the stabilizer in the group generated by `pcgs` of the point `pnt`. If given, `acts` are elements by which `pcgs` acts, `act` is the acting function. This function returns a pcgs for the stabilizer which is induced by the `ParentPcgs`

of `pcgs`, that is it is compatible with `pcgs`.

`‣ Pcgs_OrbitStabilizer` ( pcgs, domain, pnt, oprs, opr ) | ( function ) |

runs a solvable group orbit-stabilizer algorithm on `pnt` with `pcgs` acting via the images `oprs` and the operation function `opr`. The domain `domain` can be used to speed up search, if it is not known, `false`

can be given instead. The function returns a record with components `orbit`

, `stabpcgs`

and `lengths`

, the latter indicating the lengths of the orbit whenever it got extended. This can be used to recompute transversal elements. This function should be used only inside algorithms when speed is essential.

For the following operations there are special methods for groups with pcgs installed:

`IsNilpotentGroup`

(39.15-3), `IsSupersolvableGroup`

(39.15-8), `Size`

(30.4-6), `CompositionSeries`

(39.17-5), `ConjugacyClasses`

(39.10-2), `Centralizer`

(35.4-4), `FrattiniSubgroup`

(39.12-6), `PrefrattiniSubgroup`

(39.12-7), `MaximalSubgroups`

(39.19-8) and related operations, `HallSystem`

(39.13-6) and related operations, `MinimalGeneratingSet`

(39.22-3), `Centre`

(35.4-5), `Intersection`

(30.5-2), `AutomorphismGroup`

(40.7-1), `IrreducibleModules`

(71.15-1).

There are a variety of algorithms to compute conjugacy classes and centralizers in solvable groups via epimorphic images ([FN79], [MN89], [The93]). Usually these are only invoked as methods, but it is possible to access the algorithm directly.

`‣ ClassesSolvableGroup` ( G, mode[, opt] ) | ( function ) |

computes conjugacy classes and centralizers in solvable groups. `G` is the acting group. `mode` indicates the type of the calculation:

0 Conjugacy classes

4 Conjugacy test for the two elements in `opt``.candidates`

In mode 0 the function returns a list of records containing components `representative` and `centralizer`. In mode 4 it returns a conjugating element.

The optional record `opt` may contain the following components that will affect the algorithm's behaviour:

`pcgs`

is a pcgs that will be used for the calculation. The attribute

`EANormalSeriesByPcgs`

(45.11-4) must return an appropriate series of normal subgroups with elementary abelian factors among them. The algorithm will step down this series. In the case of the calculation of rational classes, it must be a pcgs refining a central series.`candidates`

is a list of elements for which canonical representatives are to be computed or for which a conjugacy test is performed. Both elements must lie in

`G`, but this is not tested. In mode 4 these elements must be given. In mode 0 a list of classes corresponding to`candidates`

is returned (which may contain duplicates). The`representative`

s chosen are canonical with respect to`pcgs`

. The records returned also contain components`operator`

such that`candidate ^ operator = representative`

.`consider`

is a function

`consider( fhome, rep, cenp, K, L )`

. Here`fhome`

is a home pcgs for the factor group \(F\) in which the calculation currently takes place,`rep`

is an element of the factor and`cenp`

is a pcgs for the centralizer of`rep`

modulo`K`

. In mode 0, when lifting from \(F\)/`K`

to \(F\)/`L`

(note: for efficiency reasons, \(F\) can be different from`G`or`L`

might be not trivial) this function is called before performing the actual lifting and only those representatives for which it returns`true`

are passed to the next level. This permits for example the calculation of only those classes with small centralizers or classes of restricted orders.

`‣ CentralizerSizeLimitConsiderFunction` ( sz ) | ( function ) |

returns a function (with arguments `fhome`

, `rep`

, `cen`

, `K`

, `L`

) that can be used in `ClassesSolvableGroup`

(45.17-1) as the `consider`

component of the options record. It will restrict the lifting to those classes, for which the size of the centralizer (in the factor) is at most `sz`.

See also `SubgroupsSolvableGroup`

(39.21-3).

generated by GAPDoc2HTML