Basic Operations

Subsections

• Accessing Group Information

Accessing Group Information

The functions in this group provide access to basic information stored for a automatic group G.

G . i : GrpAtc, RngIntElt -> GrpAtcElt

The i-th defining generator for G.

Generators(G) : GrpAtc -> [GrpAtcElt]

A sequence containing the defining generators for G.

NumberOfGenerators(G) : GrpAtc -> RngIntElt

Ngens(G) : GrpAtc -> RngIntElt

The number of defining generators for G.

Relations(G) : GrpAtc -> [GrpFPRel]

A sequence containing the defining relations for G. The relations will be given between elements of the free group of which G is a quotient. In these relations the (image of the) left hand side (in G) will always be greater than the (image of the) right hand side (in G) in the ordering on words used to construct G.

NumberOfRelations(G) : GrpAtc -> RngIntElt

Nrels(G) : GrpAtc -> RngIntElt

The number of relations in G.

Ordering(G) : GrpAtc -> String

The ordering of G.

Parent(w) : GrpAtcElt -> GrpAtc

The parent group G for the word w.

Example GrpAtc_BasicAccess (H31E4)

> F<a,b> := FreeGroup(2);
> Q := quo< F | a*a=1, b*b=b^-1, a*b^-1*a*b^-1*a=b*a*b*a*b>;
> G<a,b> := AutomaticGroup(Q);
Running Knuth-Bendix with the following parameter values
MaxRelations  = 200
MaxStates     = 0
TidyInt       = 20
MaxWdiffs     = 512
HaltingFactor = 100
MinTime       = 5
#System is confluent.
#Halting with 18 equations.
#First word-difference machine with 27 states computed.
#Second word-difference machine with 33 states computed.
#System is confluent, or halting factor condition holds.
#Word-acceptor with 28 states computed.
#General multiplier with 101 states computed.
#Validity test on general multiplier succeeded.
#General length-2 multiplier with 157 states computed.
#Checking inverse and short relations.
#Checking relation:  _3*_1*_3*_1*_3 = _1*_4*_1*_4*_1
#Axiom checking succeeded.
> G;
An automatic group.
Generator Ordering = [ a, a^-1, b, b^-1 ]
The second word difference machine has 33 states.
The word acceptor has 28 states.
> print G.1*G.2;
a * b
> print Generators(G);
[ a, b ]
> print Ngens(G);
2
> rels := Relations(G);
> print rels[1];
Q.2 * Q.2^-1 = Id(Q)
> print rels[2];
Q.2^-1 * Q.2 = Id(Q)
> print rels[3];
Q.1^2 = Id(Q)
> print rels[4];
Q.2^2 = Q.2^-1
> print Nrels(G);
18
> print Ordering(G);
ShortLex