%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%
%W  defins.tex             GAP documentation                 Bettina Eick
%W                                                          Werner Nickel
%%
%H  $Id: defins.tex,v 1.5 2003/10/24 15:35:11 gap Exp $
%%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Chapter{Pcp-groups - polycyclically presented groups}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{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 \Z$ 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 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 $[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> )

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

\>IsPcpElementRep( <obj> )

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

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{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.  

\bigskip

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

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Pcp-groups - groups of pcp-elements}

\label{pcpgroup}

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

\beginexample
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 ]
\endexample

