A pcp-element is an element of a group defined by a consistent pc-presentation given by a collector. Suppose that g_1, ..., 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 ⋯ g_n^e_n with e_i ∈ ℤ and 0 ≤ e_i < r_i for i ∈ I. The integer vector [e_1, ..., 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, ..., 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, ..., g_n a polycyclic generating sequence of the underlying pc-presented group. Let C_1, ..., C_n be the polycyclic series defined by g_1, ..., 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 ∈ C_i ∖ C_i+1. The depth of the trivial element is defined to be n+1. If gnot=1 has depth i and g_i^e_i ⋯ 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 < ∞, then the smallest positive integer l with g^l ∈ C_i+1 is the called relative order of g. If r=∞, then the relative order of g is defined to be 0. The index e of ⟨ g,C_i+1⟩ 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