[Next][Prev] [Right] [Left] [Up] [Index] [Root]

Arithmetic with Words

Subsections

Construction of a Word

G ! [ i1, ..., is ] : GrpAtc, [ RngIntElt ] -> GrpAtcElt
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.
Identity(G) : GrpAtc -> GrpAtcElt
Id(G) : GrpAtc -> GrpAtcElt
G ! 1 : GrpAtc, RngIntElt -> GrpAtcElt
Construct the identity word in the automatic group G.
Parent(w) : GrpAtcElt -> GrpAtc
The parent group G for the word w.

Example GrpAtc_Words (H75E7)

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

Operations on Elements

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.
u * v : GrpRWSElt, GrpRWSElt -> GrpRWSElt
Given words w and v belonging to a common group, return their product.
u / v : GrpRWSElt, GrpRWSElt -> GrpRWSElt
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.

u ^ n : GrpRWSElt, RngIntElt -> GrpRWSElt
The n-th power of the word w.
u ^ v : GrpRWSElt, GrpRWSElt -> GrpRWSElt
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.
Inverse(w) : GrpRWSElt -> GrpRWSElt
The inverse of the word w.
(u, v) : GrpRWSElt, GrpRWSElt -> GrpRWSElt
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.

(u1, ..., ur) : GrpRWSElt, ..., GrpRWSElt -> GrpRWSElt
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.

u eq v : GrpRWSElt, GrpRWSElt -> BoolElt
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.
u ne v : GrpRWSElt, GrpRWSElt -> BoolElt
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.
IsId(w) : GrpRWSElt -> BoolElt
IsIdentity(w) : GrpRWSElt -> BoolElt
Returns true if the word w is the identity word.
# u : GrpRWSElt -> RngIntElt
The length of the word w.
ElementToSequence(u) : GrpRWSElt -> [ RngIntElt ]
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.

Example GrpAtc_Arithmetic (H75E8)

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]

Version: V2.19 of Mon Dec 17 14:40:36 EST 2012