GAP (polycyclic) - Chapter 4: Pcp-groups - polycyclically presented groups

Goto Chapter: Top 1 2 3 4 5 6 7 8 9 A Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax off]

4 Pcp-groups - polycyclically presented groups
4.1 Pcp-elements -- elements of a pc-presented group
4.1-1 PcpElementByExponentsNC
4.1-2 PcpElementByGenExpListNC
4.1-3 IsPcpElement
4.1-4 IsPcpElementRep
4.2 Methods for pcp-elements
4.2-1 Collector
4.2-2 Exponents
4.2-3 GenExpList
4.2-4 NameTag
4.2-5 Depth
4.2-6 LeadingExponent
4.2-7 RelativeOrder
4.2-8 RelativeIndex
4.2-9 FactorOrder
4.2-10 NormingExponent
4.2-11 NormedPcpElement
4.3 Pcp-groups - groups of pcp-elements
4.3-1 PcpGroupByCollector
4.3-2 Group
4.3-3 Subgroup

### 4 Pcp-groups - polycyclically presented groups

#### 4.1 Pcp-elements -- elements of a pc-presented group

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.

##### 4.1-1 PcpElementByExponentsNC

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

##### 4.1-2 PcpElementByGenExpListNC

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

##### 4.1-3 IsPcpElement

`‣ IsPcpElement`( obj ) | ( category )

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

##### 4.1-4 IsPcpElementRep

`‣ IsPcpElementRep`( obj ) | ( representation )

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

#### 4.2 Methods for pcp-elements

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.

##### 4.2-1 Collector

`‣ Collector`( g ) | ( operation )

the collector to which the pcp-element g belongs.

##### 4.2-2 Exponents

`‣ Exponents`( g ) | ( operation )

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

##### 4.2-3 GenExpList

`‣ GenExpList`( g ) | ( operation )

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

##### 4.2-4 NameTag

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

##### 4.2-5 Depth

`‣ Depth`( g ) | ( operation )

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

##### 4.2-6 LeadingExponent

`‣ 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'

##### 4.2-7 RelativeOrder

`‣ RelativeOrder`( g ) | ( attribute )

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

##### 4.2-8 RelativeIndex

`‣ RelativeIndex`( g ) | ( attribute )

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

##### 4.2-9 FactorOrder

`‣ FactorOrder`( g ) | ( attribute )

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

##### 4.2-10 NormingExponent

`‣ NormingExponent`( g ) | ( function )

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

##### 4.2-11 NormedPcpElement

`‣ NormedPcpElement`( g ) | ( function )

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

#### 4.3 Pcp-groups - groups of pcp-elements

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.

##### 4.3-1 PcpGroupByCollector

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

##### 4.3-2 Group

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

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

##### 4.3-3 Subgroup

`‣ 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 ]

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 A Bib Ind

generated by GAPDoc2HTML