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, ..., 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.

`‣ 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, ..., 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