|
|
Id(G) : GrpRWS -> GrpRWSElt
G ! 1 : GrpRWS, RngIntElt -> GrpRWSElt
Construct the identity word in G.
Given a rewrite group G defined on r generators and a sequence
[i1, ..., is] of integers lying in the range [ - r, r],
excluding 0, construct the word
G.|i1|ε1 * G.|i2|ε2 * ... * G.|is|εs
where εj is +1 if ij is positive, and -1 if ij is
negative. The resulting word is reduced using the reduction machine
associated with G.
The parent group G for the word w.
We construct the Fibonacci group F(2, 7), and its identity.
> FG<a,b,c,d,e,f,g> := FreeGroup(7);
> F := quo< FG | a*b=c, b*c=d, c*d=e, d*e=f, e*f=g, f*g=a, g*a=b>;
> G := RWSGroup(F : TidyInt := 1000);
> Id(G);
Id(G)
> G!1;
Id(G)
> G![1,2];
G.3
Having constructed a rewrite group G one can perform arithmetic with words
in G. Assuming we have u, v ∈G then the product u * v will be computed
as follows:
- (i)
- the product w = u * v is formed as a product in the appropriate
free group.
- (ii)
- w is reduced using the reduction machine associated with G.
If G is confluent, then w will be the unique minimal word that represents
u * v under the ordering of G. If G is not confluent, then there are
some pairs of words which are equal in G, but which reduce to distinct words,
and hence w will not be a unique normal form. Note that:
- (i)
- reduction of w can cause an increase in the length of w. At
present there is an internal limit on the length of a word -- if this limit
is exceeded during reduction an error will be raised. Hence any word operation
involving reduction can fail.
- (ii)
- the implementation is designed more with speed of execution in
mind than with minimizing space requirements; thus, the reduction machine is
always used to carry out word reduction, which can be space-consuming,
particularly when the number of generators is large.
Given words w and v belonging to a common group,
return their product.
Given words w and v belonging to a common group,
return the product of the word u by the inverse of
the word v, i.e. the word u * v - 1.
The n-th power of the word w.
Given words w and v belonging to a common group,
return the conjugate of the word u by the word v,
i.e. the word v - 1 * u * v.
The inverse of the word w.
Given words w and v belonging to a common group,
return the commutator of the words u and v,
i.e., the word u - 1v - 1uv.
Given r words u1, ..., ur belonging to a common group,
return their commutator. Commutators are left-normed, so they are
evaluated from left to right.
Given words w and v belonging to the same group, return true
if w and v reduce to the same normal form, false otherwise. If G is
confluent this tests for equality. If G is non-confluent
then two words which are the same may not reduce to the same normal form.
Given words w and v belonging to the same group, return false
if w and v reduce to the same normal form, true otherwise. If G is
confluent this tests for non-equality. If G is non-confluent
then two words which are the same may reduce to different normal forms.
IsIdentity(w) : GrpRWSElt -> BoolElt
Returns true if the word w is the identity word.
The length of the word w.
Eltseq(u) : GrpRWSElt -> [ RngIntElt ]
The sequence Q obtained by decomposing the element u of a rewrite group
into its constituent
generators and generator inverses. Suppose u is a word in the rewrite
group G. Then, if u = G.i1e1 ... G.imem, with
each ei equaling plus or minus 1,
then Q[j] = ij if ej = + 1 and Q[j] = - ij if ej = (-1), for
j = 1, ..., m.
We illustrate the word operations by applying them to elements of
the Fibonacci group F(2, 5).
> FG<a,b,c,d,e> := FreeGroup(5);
> F := quo< FG | a*b=c, b*c=d, c*d=e, d*e=a, e*a=b>;
> G<a,b,c,d,e> := RWSGroup(F);
> a*b^-1;
e^-1
> a/b;
e^-1
> (c*d)^4;
a
> a^b, b^-1*a*b;
a a
> a^-2,
> Inverse(a)^2;
d d
> c^-1*d^-1*c*d eq (c,d);
true
> IsIdentity(a*b*c^-1);
true
> #(c*d);
1
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|
|