[Up] [Previous] [Next] [Index]

# 4 Pcp-groups - polycyclically presented groups

### Sections

1. Pcp-elements -- elements of a pc-presented group
2. Methods for pcp-elements
3. Pcp-groups - groups of pcp-elements

## 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 g1, ..., gn are the defining generators of the collector. Recall that each element g in this group can be written uniquely as a collected word g1e_1 cdotsgne_n with ei inZ and 0 leqei < ri for i in I. The integer vector [e1, ..., en] 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 Section Collectors.

- `PcpElementByExponentsNC(` coll`,` exp`)`
- `PcpElementByExponents(` coll`,` exp`)`

  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`)`
- `PcpElementByGenExpList(` coll`,` word`)`

  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 [i1, ei_1, i2, ei_2, ..., ir, ei_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`)`

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

- `IsPcpElementRep(` obj`)`

  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 g1, ..., gn a polycyclic generating sequence of the underlying pc-presented group. Let C1, ..., Cn be the polycyclic series defined by g1, ..., gn.

  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 inCi setminusCi+1. The depth of the trivial element is defined to be n+1. If gnot=1 has depth i and gie_i cdotsgne_n is the collected word for g, then ei is the leading exponent of g.

  If g has depth i, then we call ri = [Ci:Ci+1] the factor order of g. If r<infty, then the smallest positive integer l with gl inCi+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 langleg,Ci+1rangle in Ci 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 ge is normed.

- `Collector(` g`)`

  the collector to which the pcp-element g belongs.

- `Exponents(` g`)`

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

- `GenExpList(` g`)`

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

- `NameTag(` g`)`

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

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

- `LeadingExponent(` g`)`

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

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

- `RelativeIndex(` g`)`

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

- `FactorOrder(` g`)`

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

- `NormingExponent(` g`)`

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

- `NormedPcpElement(` g`)`

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

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

  labelpcpgroup

  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`)`
- `PcpGroupByCollectorNC(` coll`)`

  returns a pcp-group build from the collector coll.

  The function calls `UpdatePolycyclicCollector` (see UpdatePolycyclicCollector) and checks the confluence (see IsConfluent) of the collector.

  The non-check version bypasses these checks.

- `Group(` gens`,` id`)`

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

- `Subgroup(` G`,` gens`)`

  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 ]

  [Up] [Previous] [Next] [Index]