[Next][Prev] [Right] [Left] [Up] [Index] [Root]
Subsections
Given an automatic 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 word will be returned in reduced form.
Id(G) : GrpAtc -> GrpAtcElt
G ! 1 : GrpAtc, RngIntElt -> GrpAtcElt
Construct the identity word in the automatic group G.
The parent group G for the word w.
We construct some words in a two-generator two-relator group.
> F<a, b> := Group< a, b | a^2 = b^2, a*b*a = b*a*b >;
> f, G<a, b> := IsAutomaticGroup(F);
> G;
An automatic group.
Generator Ordering = [ $.1, $.1^-1, $.2, $.2^-1 ]
The second word difference machine has 11 states.
The word acceptor has 8 states.
> Id(G);
Id(G)
> print G!1;
Id(G)
> a*b*a*b^3;
a^4 * b * a
> G![1,2,1,2,2,2];
a^4 * b * a
Having constructed an automatic 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 second word difference machine associated
with G.
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
fundamental group of a 3-manifold.
We illustrate the word operations by applying them to elements of a
free group of rank two (with lots of redundant generators).
> FG<a,b,c,d,e> := FreeGroup(5);
> F := quo< FG | a*d*d=1, b*d*d*d=1, c*d*d*d*d*d*e*e*e=1>;
> f, G<a,b,c,d,e> := IsAutomaticGroup(F);
> G;
An automatic group.
Generator Ordering = [ a, a^-1, b, b^-1, c, c^-1, d, d^-1, e, e^-1 ]
The second word difference machine has 41 states.
The word acceptor has 42 states.
> print a*d;
d^-1
> print a/(d^-1);
d^-1
> print c*d^5*e^2;
e^-1
> print a^b, b^-1*a*b;
a a
> print (a*d)^-2, Inverse(a*d)^2;
a^-1 a^-1
> print c^-1*d^-1*c*d eq (c,d);
true
> print IsIdentity(b*d^3);
true
> print #(c*d*d*d*d*d*e*e);
1
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|
