Operations on the Set of Elements

Subsections

• Order Functions
• Set Operations
• Membership and Equality

Order Functions

Order(G) : GrpRWS -> RngIntElt

# G : GrpRWS -> RngIntElt

The order of the group G as an integer. If the order of G is known to be infinite Infinity is returned.

IsFinite(G) : GrpRWS -> BoolElt, RngIntElt

Given a confluent group G return true if G has finite order and false otherwise. If G does have finite order also return the order of G.

Example GrpRWS_Order (H30E5)

(1)

We construct the infinite cyclic group and compute it's order. The result of Infinity indicates that the group has infinite order.

> FG<a> := FreeGroup(1);
> G := RWSGroup(FG);
> print Order(G);
Infinity

(2)

We construct S_9 and test whether or not it has finite order.

> FG<a,b,c,d,e,f,g,h> := FreeGroup(8);
> Q := quo< FG |
>   a^2=1, b^2=1, c^2=1, d^2=1, e^2=1, f^2=1, g^2=1, h^2=1,
>   b*a*b=a*b*a, c*a=a*c, d*a=a*d, e*a=a*e, f*a=a*f, g*a=a*g, 
>   h*a=a*h, c*b*c=b*c*b, d*b=b*d, e*b=b*e, f*b=b*f, g*b=b*g, 
>   h*b=b*h, d*c*d=c*d*c, e*c=c*e, f*c=c*f, g*c=c*g, h*c=c*h,
>   e*d*e=d*e*d, f*d=d*f, g*d=d*g, h*d=d*h, f*e*f=e*f*e, 
>   g*e=e*g, h*e=e*h, g*f*g=f*g*f, h*f=f*h, h*g*h=g*h*g>;
> G := RWSGroup(Q);
> print IsFinite(G);
true
> isf, ord := IsFinite(G);
> print isf, ord;
true 362880

Set Operations

Random(G, n) : GrpRWS, RngIntElt -> GrpRWSElt

A random word of length at most n in the generators of G.

Random(G) : GrpRWS -> GrpRWSElt

A random word (of length at most the order of G) in the generators of G.

Representative(G) : GrpRWS -> GrpRWSElt

Rep(G) : GrpRWS -> GrpRWSElt

An element chosen from G.

Set(G, a, b) : GrpRWS, RngIntElt, RngIntElt -> SetEnum

    Search: MonStgElt                   Default: "DFS"

Create the set of words, w, in G with a <= length(w) <= b. If Search is set to "DFS" (depth-first search) then words are enumerated in lexicographical order. If Search is set to "BFS" (breadth-first-search) then words are enumerated in lexicographical order for each individual length (i.e. in short-lex order). Depth-first-search is marginally quicker. Since the result is a set the words may not appear in the resultant set in the search order specified (although internally they will be enumerated in this order).

Set(G) : GrpRWS -> SetEnum

    Search: MonStgElt                   Default: "DFS"

Create the set of words that is the carrier set of G. If Search is set to "DFS" (depth-first search) then words are enumerated in lexicographical order. If Search is set to "BFS" (breadth-first-search) then words are enumerated in lexicographical order for each individual length (i.e. in short-lex order). Depth-first-search is marginally quicker. Since the result is a set the words may not appear in the resultant set in the search order specified (although internally they will be enumerated in this order).

Seq(G, a, b) : GrpRWS, RngIntElt, RngIntElt -> SeqEnum

    Search: MonStgElt                   Default: "DFS"

Create the sequence S of words, w, in G with a <= length(w) <= b. If Search is set to "DFS" (depth-first search) then words will appear in S in lexicographical order. If Search is set to "BFS" (breadth-first-search) then words will appear in S in lexicographical order for each individual length (i.e. in short-lex order). Depth-first-search is marginally quicker.

Seq(G) : GrpRWS -> SeqEnum

    Search: MonStgElt                   Default: "DFS"

Create a sequence S of words from the carrier set of G. If Search is set to "DFS" (depth-first search) then words will appear in S in lexicographical order. If Search is set to "BFS" (breadth-first-search) then words will appear in S in lexicographical order for each individual length (i.e. in short-lex order). Depth-first-search is marginally quicker.

Example GrpRWS_Set (H30E6)

> FG<a,b,c,d,e,f> := FreeGroup(6);
> Q := quo< FG | a*c^-1*a^-1*d=1, b*f*b^-1*e^-1=1, c*e*c^-1*d^-1=1,
>                 d*f^-1*d^-1*a=1, e*b*e^-1*a^-1=1, f*c^-1*f^-1*b^-1=1>;
> G<a,b,c,d,e,f> := RWSGroup(Q);
> print Representative(G);
Id(G)
> print Random(G);
b
> print Random(G, 5);
a * d * b
> Set(G);
{ a * d * b, a * b, a * b * e, a * c, a * d, d * b, b * e, a * b * a, a * b * d,
b * a, a * c * e, Id(G), b * d, c * e, e, f, a, a * e, b, c, a * f, d }
> Seq(G : Search := "DFS");
[ Id(G), a, a * b, a * b * a, a * b * d, a * b * e, a * c, a * c * e, a * d, a *
d * b, a * e, a * f, b, b * a, b * d, b * e, c, c * e, d, d * b, e, f ]

Membership and Equality

w in G : GrpRWSElt, GrpRWS -> BoolElt

Given a word w and a rewrite group G, return true if w is an element of G, false otherwise.

w notin G : GrpRWSElt, GrpRWS -> BoolElt

Given a word w and a rewrite group G, return true if w is not an element of G, false otherwise.

S subset G : { GrpRWSElt }, GrpRWS -> BoolElt

Given a rewrite group G and a set (or sequence) S of words return true if every member of S is an element of G, false otherwise.

S notsubset G : { GrpRWSElt }, GrpRWS -> BoolElt

Given a rewrite group G and a set (or sequence) S of words return true if any member of S is not an element of G, false otherwise.