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.
‣ IsPcpElementCollection( obj ) | ( category ) |
returns true if the object obj is a collection of pcp-elements.
‣ IsPcpElementRep( obj ) | ( representation ) |
returns true if the object obj is represented as a pcp-element.
‣ IsPcpGroup( obj ) | ( filter ) |
returns true if the object obj is a group and also a pcp-element collection.
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