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

Creation of Automatic Groups

Subsections

Construction of an Automatic Group

AutomaticGroup(F: parameters) : GrpFP -> GrpAtc
IsAutomaticGroup(F: parameters) : GrpFP -> BoolElt, GrpAtc
Internally a monoid presentation P of the group F is constructed. By default the generators of P are taken to be g1, (g1) - 1, ..., gn, (gn) - 1 where g1, ..., gn are the generators of F. The relations of P are taken to be the relations of F. The trivial relations between the generators and their inverses are also added. The word ordering is the short-lex ordering. The Knuth--Bendix completion procedure for monoids is now run on P to calculate the word difference automata corresponding to the generated equations, which are then used to calculate the finite state automata associated with a short-lex automatic group. In successful cases these automata are proved correct in the final step.

If the procedure succeeds the result will be an automatic group, G, containing four automata. These are the first and second word-difference machines, the word acceptor, and the word multiplier. The form AutomaticGroup returns an automatic group while the form IsAutomaticGroup returns the boolean value true and the automatic group. If the procedure fails, the first form does not return a value while the second returns the boolean value false.

For simple examples, the algorithms work quickly, and do not require much space. For more difficult examples, the algorithms are often capable of completing successfully, but they can sometimes be expensive in terms of time and space requirements. Another point to be borne in mind is that the algorithms sometimes produce temporary disk files which the user does not normally see (because they are automatically removed after use), but can occasionally be very large. These files are stored in the /tmp directory. If you interrupt a running automatic group calculation you must remove these temporary files yourself.

As the Knuth--Bendix procedure will more often than not run forever, some conditions must be specified under which it will stop. These take the form of limits that are placed on certain variables, such as the number of reduction relations. If any of these limits are exceeded during a run of the completion procedure it will fail, returning a non-confluent automatic group. The optimal values for these limits varies from example to example. Some of these limits may be specified by setting parameters (see the next section). In particular, if a first attempt to compute the automatic structure of a group fails, it should be run again with the parameter Large (or Huge) set to {true}.


Example GrpAtc_AutomaticGroup (H75E1)

We construct the automatic structure for the fundamental group of the torus. Since a generator ordering is not specified, the default generator ordering, [ a, a - 1, b, b - 1, c, c - 1, d, d - 1], is used.

> FG<a,b,c,d> := FreeGroup(4);
> F := quo< FG | a^-1*b^-1*a*b=d^-1*c^-1*d*c>;
> f, G := IsAutomaticGroup(F);

Running Knuth-Bendix with the following parameter values
MaxRelations  = 200
MaxStates     = 0
TidyInt       = 20
MaxWdiffs     = 512
HaltingFactor = 100
MinTime       = 5
#Halting with 118 equations.
#First word-difference machine with 33 states computed.
#Second word-difference machine with 33 states computed.
#System is confluent, or halting factor condition holds.
#Word-acceptor with 36 states computed.
#General multiplier with 104 states computed.
#Validity test on general multiplier succeeded.
#General length-2 multiplier with 220 states computed.
#Checking inverse and short relations.
#Checking relation:  _8*_6*_7*_5 = _2*_4*_1*_3
#Axiom checking succeeded.

> G;

An automatic group.
Generator Ordering = [ a, a^-1, b, b^-1, c, c^-1, d, d^-1 ]
The second word difference machine has 33 states.
The word acceptor has 36 states.

Modifying Limits

In this section we describe the various parameters used to control the execution of the procedures employed to determine the automatic structure.

AutomaticGroup(F: parameters) : GrpFP -> GrpAtc
IsAutomaticGroup(F: parameters) : GrpFP -> BoolElt, GrpAtc
Attempt to construct an automatic structure for the finitely presented group F (see the main entry). We now present details of the various parameters used to control the execution of the procedures.

     Large: BoolElt                      Default: false

If Large is set to true large hash tables are used internally. Also the Knuth--Bendix algorithm is run with larger parameters, specifically TidyInt is set to 500, MaxRelations is set to 262144, MaxStates is set to unlimited, HaltingFactor is set to 100, MinTime is set to 20 and ConfNum is set to 0. It is advisable to use this option only after having first tried without it, since it will result in much longer execution times for easy examples.

     Huge: BoolElt                       Default: false

Setting Huge to true doubles the size of the hash tables and MaxRelations over the Large parameter. As with the Large parameter, it is advisable to use this option only after having first tried without it.

     MaxRelations: RngIntElt             Default: 200

Limit the maximum number of reduction equations to MaxRelations.

     TidyInt: RngIntElt                  Default: 20

After finding n new reduction equations, the completion procedure interrupts the main process of looking for overlaps, to tidy up the existing set of equations. This will eliminate any redundant equations performing some reductions on their left and right hand sides to make the set as compact as possible. (The point is that equations discovered later often make older equations redundant or too long.) The word-differences arising from the equations are calculated after each such tidying and the number reported if verbose printing is on. The best strategy in general is to try a small value of TidyInt first and, if that is not successful, try increasing it. Large values such as 1000 work best in really difficult examples.

     GeneratorOrder: SeqEnum             Default: 

Give an ordering for the generators of P. This ordering affects the ordering of words in the alphabet. If not specified, the ordering defaults to [g1, (g1) - 1, ..., gn, (gn) - 1] where g1, ..., gn are the generators of F.

     MaxWordDiffs: RngIntElt             Default: 

Limit the maximum number of word differences to MaxWordDiffs. The default behaviour is to increase the number of allowed word differences dynamically as required, and so usually one does not need to set this option.

     HaltingFactor: RngIntElt            Default: 100

     MinTime: RngIntElt                  Default: 5

These options are experimental halting options. HaltingFactor is a positive integer representing a percentage. After each tidying it is checked whether both the number of equations and the number of states have increased by more than HaltingFactor percent since the number of word-differences was last less than what it is now. If so the program halts. A sensible value seems to be 100, but occasionally a larger value is necessary. If the MinTime option is also set then halting only occurs if at least MinTime seconds of cpu-time have elapsed altogether. This is sometimes necessary to prevent very early premature halting. It is not very satisfactory, because of course the cpu-time depends heavily on the particular computer being used, but no reasonable alternative has been found yet.

SetVerbose("KBMAG", v) : MonStgElt, RngIntElt ->
Set the verbose printing level for the Knuth--Bendix completion algorithm. Setting this level allows a user to control how much extra information on the progress of the algorithm is printed. Currently the legal values for v are 0 to 3 inclusive. Setting v to 0 corresponds to the `-silent' option of KBMAG in which no extra output is printed. Setting v to 2 corresponds to the `-v' (verbose) option of KBMAG in which a small amount of extra output is printed. Setting v to 3 corresponds to the `-vv' (very verbose) option of KBMAG in which a huge amount of diagnostic information is printed.

Example GrpAtc_AutomaticGroup-3 (H75E2)

We attempt to construct an automatic structure for one of Listing's knot groups.

> F := Group< d, f | f*d*f^-1*d*f*d^-1*f^-1*d*f^-1*d^-1=1>;
> b, G := IsAutomaticGroup(F); 
Running Knuth-Bendix with the following parameter values
MaxRelations  = 200
MaxStates     = 0
TidyInt       = 20
MaxWdiffs     = 512
HaltingFactor = 100
MinTime       = 5
#Maximum number of equations exceeded.
#Halting with 195 equations.
#First word-difference machine with 45 states computed.
#Second word-difference machine with 53 states computed.
> b;
false;

So this attempt has failed. We run the IsAutomaticGroup function again setting Large to true. This time we succeed.

> f, G := IsAutomaticGroup(F : Large := true);
Running Knuth-Bendix with the following parameter values
MaxRelations  = 262144
MaxStates     = 0
TidyInt       = 500
MaxWdiffs     = 512
HaltingFactor = 100
MinTime       = 5
#Halting with 3055 equations.
#First word-difference machine with 49 states computed.
#Second word-difference machine with 61 states computed.
#System is confluent, or halting factor condition holds.
#Word-acceptor with 101 states computed.
#General multiplier with 497 states computed.
#Multiplier incorrect with generator number 3.
#General multiplier with 509 states computed.
#Multiplier incorrect with generator number 3.
#General multiplier with 521 states computed.
#Multiplier incorrect with generator number 3.
#General multiplier with 525 states computed.
#Validity test on general multiplier succeeded.
#General length-2 multiplier with 835 states computed.
#Checking inverse and short relations.
#Checking relation:  _3*_1*_4*_1*_3 = _1*_3*_2*_3*_1
#Axiom checking succeeded.
> G;
An automatic group.
Generator Ordering = [ d, d^-1, f, f^-1 ]
The second word difference machine has 89 states.
The word acceptor has 101 states.

Example GrpAtc_AutomaticGroup-4 (H75E3)

We construct the automatic group corresponding to the fundamental group of the trefoil knot. A generator order is specified.

> F<a, b> := Group< a, b | b*a^-1*b=a^-1*b*a^-1>;
> f, G := IsAutomaticGroup(F: GeneratorOrder := [a,a^-1, b, b^-1]);

Running Knuth-Bendix with the following parameter values
MaxRelations  = 200
MaxStates     = 0
TidyInt       = 20
MaxWdiffs     = 512
HaltingFactor = 100
MinTime       = 5
#Halting with 83 equations.
#First word-difference machine with 15 states computed.
#Second word-difference machine with 17 states computed.
#System is confluent, or halting factor condition holds.
#Word-acceptor with 15 states computed.
#General multiplier with 67 states computed.
#Multiplier incorrect with generator number 4.
#General multiplier with 71 states computed.
#Validity test on general multiplier succeeded.
#General length-2 multiplier with 361 states computed.
#Checking inverse and short relations.
#Checking relation:  _3*_2*_3 = _2*_3*_2
#Axiom checking succeeded.

> G;

An automatic group.
Generator Ordering = [ a, a^-1, b, b^-1 ]
The second word difference machine has 21 states.
The word acceptor has 15 states.

Accessing Group Information

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

G . i : GrpRWS, RngIntElt -> GrpRWSElt
The i-th defining generator for G. The integer i must lie in the range [ - r, r], where r is the number of group G.
Generators(G) : GrpRWS -> [GrpRWSElt]
A sequence containing the defining generators for G.
NumberOfGenerators(G) : GrpRWS -> RngIntElt
Ngens(G) : GrpRWS -> RngIntElt
The number of defining generators for G.

Example GrpAtc_BasicAccess (H75E4)

We illustrate the access operations using the Von Dyck (2,3,5) group (isomorphic to A5).

> 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>;
> f, G<a,b> := IsAutomaticGroup(Q);
> 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

FPGroup(G) : GrpAtc -> GrpFP, Map
Returns the finitely presented group F used in the construction of G, and the isomorphism from F to G.
WordAcceptor(G) : GrpAtc -> Rec
A record describing the word acceptor automaton stored in G.
WordAcceptorSize(G) : GrpAtc -> RngIntElt, RngIntElt
The number of states of the word acceptor automaton stored in G, and the size of the alphabet of this automaton.
WordDifferenceAutomaton(G) : GrpAtc -> Rec
A record describing the word difference automaton stored in G.
WordDifferenceSize(G) : GrpAtc -> RngIntElt, RngIntElt
The number of states of the 2nd word difference automaton stored in G, and the size of the alphabet of this automaton.
WordDifferences(G) : GrpAtc -> SeqEnum
The labels of the states of the word difference automaton stored in G. The result is a sequence of elements of the finitely presented group used in the construction of G.
GeneratorOrder(G) : GrpAtc -> SeqEnum
The value of the GeneratorOrder parameter used in the construction of G. The result is a sequence of generators and their inverses from the finitely presented group used in the construction of G.
 [Next][Prev] [Right] [Left] [Up] [Index] [Root]

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