4 Pcp-groups - polycyclically presented groups

A *pcp-element* is an element of a group defined by a consistent pc-presentation given by a collector. Suppose that \(g_1, \ldots, g_n\) are the defining generators of the collector. Recall that each element \(g\) in this group can be written uniquely as a collected word \(g_1^{e_1} \cdots g_n^{e_n}\) with \(e_i \in ℤ\) and \(0 \leq e_i < r_i\) for \(i \in I\). The integer vector \([e_1, \ldots, e_n]\) is called the *exponent vector* of \(g\). The following functions can be used to define pcp-elements via their exponent vector or via an arbitrary generator exponent word as introduced in Chapter 3.

`‣ PcpElementByExponentsNC` ( coll, exp ) | ( function ) |

`‣ PcpElementByExponents` ( coll, exp ) | ( function ) |

returns the pcp-element with exponent vector `exp`. The exponent vector is considered relative to the defining generators of the pc-presentation.

`‣ PcpElementByGenExpListNC` ( coll, word ) | ( function ) |

`‣ PcpElementByGenExpList` ( coll, word ) | ( function ) |

returns the pcp-element with generators exponent list `word`. This list `word` consists of a sequence of generator numbers and their corresponding exponents and is of the form \([i_1, e_{i_1}, i_2, e_{i_2}, \ldots, i_r, e_{i_r}]\). The generators exponent list is considered relative to the defining generators of the pc-presentation.

These functions return pcp-elements in the category `IsPcpElement`

. Presently, the only representation implemented for this category is `IsPcpElementRep`

. (This allows us to be a little sloppy right now. The basic set of operations for `IsPcpElement`

has not been defined yet. This is going to happen in one of the next version, certainly as soon as the need for different representations arises.)

`‣ IsPcpElement` ( obj ) | ( category ) |

returns true if the object `obj` is a pcp-element.

`‣ IsPcpElementRep` ( obj ) | ( representation ) |

returns true if the object `obj` is represented as a pcp-element.

Now we can describe attributes and functions for pcp-elements. The four basic attributes of a pcp-element, `Collector`

, `Exponents`

, `GenExpList`

and `NameTag`

are computed at the creation of the pcp-element. All other attributes are determined at runtime.

Let `g` be a pcp-element and \(g_1, \ldots, g_n\) a polycyclic generating sequence of the underlying pc-presented group. Let \(C_1, \ldots, C_n\) be the polycyclic series defined by \(g_1, \ldots, g_n\).

The *depth* of a non-trivial element \(g\) of a pcp-group (with respect to the defining generators) is the integer \(i\) such that \(g \in C_i \setminus C_{i+1}\). The depth of the trivial element is defined to be \(n+1\). If \(g\not=1\) has depth \(i\) and \(g_i^{e_i} \cdots g_n^{e_n}\) is the collected word for \(g\), then \(e_i\) is the *leading exponent* of \(g\).

If \(g\) has depth \(i\), then we call \(r_i = [C_i:C_{i+1}]\) the *factor order* of \(g\). If \(r < \infty\), then the smallest positive integer \(l\) with \(g^l \in C_{i+1}\) is the called *relative order* of \(g\). If \(r=\infty\), then the relative order of \(g\) is defined to be \(0\). The index \(e\) of \(\langle g,C_{i+1}\rangle\) in \(C_i\) is called *relative index* of \(g\). We have that \(r = el\).

We call a pcp-element *normed*, if its leading exponent is equal to its relative index. For each pcp-element \(g\) there exists an integer \(e\) such that \(g^e\) is normed.

`‣ Collector` ( g ) | ( operation ) |

the collector to which the pcp-element `g` belongs.

`‣ Exponents` ( g ) | ( operation ) |

returns the exponent vector of the pcp-element `g` with respect to the defining generating set of the underlying collector.

`‣ GenExpList` ( g ) | ( operation ) |

returns the generators exponent list of the pcp-element `g` with respect to the defining generating set of the underlying collector.

`‣ NameTag` ( g ) | ( operation ) |

the name used for printing the pcp-element `g`. Printing is done by using the name tag and appending the generator number of `g`.

`‣ Depth` ( g ) | ( operation ) |

returns the depth of the pcp-element `g` relative to the defining generators.

`‣ LeadingExponent` ( g ) | ( operation ) |

returns the leading exponent of pcp-element `g` relative to the defining generators. If `g` is the identity element, the functions returns 'fail'

`‣ RelativeOrder` ( g ) | ( attribute ) |

returns the relative order of the pcp-element `g` with respect to the defining generators.

`‣ RelativeIndex` ( g ) | ( attribute ) |

returns the relative index of the pcp-element `g` with respect to the defining generators.

`‣ FactorOrder` ( g ) | ( attribute ) |

returns the factor order of the pcp-element `g` with respect to the defining generators.

`‣ NormingExponent` ( g ) | ( function ) |

returns a positive integer \(e\) such that the pcp-element `g` raised to the power of \(e\) is normed.

`‣ NormedPcpElement` ( g ) | ( function ) |

returns the normed element corresponding to the pcp-element `g`.

A *pcp-group* is a group consisting of pcp-elements such that all pcp-elements in the group share the same collector. Thus the group \(G\) defined by a polycyclic presentation and all its subgroups are pcp-groups.

`‣ PcpGroupByCollector` ( coll ) | ( function ) |

`‣ PcpGroupByCollectorNC` ( coll ) | ( function ) |

returns a pcp-group build from the collector `coll`.

The function calls `UpdatePolycyclicCollector`

(3.1-6) and checks the confluence (see `IsConfluent`

(3.1-7)) of the collector.

The non-check version bypasses these checks.

`‣ Group` ( gens, id ) | ( function ) |

returns the group generated by the pcp-elements `gens` with identity `id`.

`‣ Subgroup` ( G, gens ) | ( function ) |

returns a subgroup of the pcp-group `G` generated by the list `gens` of pcp-elements from `G`.

gap> ftl := FromTheLeftCollector( 2 );; gap> SetRelativeOrder( ftl, 1, 2 ); gap> SetConjugate( ftl, 2, 1, [2,-1] ); gap> UpdatePolycyclicCollector( ftl ); gap> G:= PcpGroupByCollectorNC( ftl ); Pcp-group with orders [ 2, 0 ] gap> Subgroup( G, GeneratorsOfGroup(G){[2]} ); Pcp-group with orders [ 0 ]

generated by GAPDoc2HTML