|
This section describes the facilities for creating elements of a braid group.
Rep(B) : GrpBrd -> GrpBrdElt
Given a braid group B, return a representative of B.
Id(B) : GrpBrd -> GrpBrdElt
B ! 1 : GrpBrd, RngIntElt -> GrpBrdElt
Given a braid group B, return the identity element of B.
Presentation: MonStgElt Default:
Return the fundamental element for the presentation of B
indicated by the parameter Presentation. Possible values for this
parameter are "Artin" and "BKL".
If the parameter Presentation is not used, the fundamental element
for the presentation currently selected for B is returned.
Presentation: MonStgElt Default:
Return a sequence containing the generators for the presentation of B
indicated by the parameter Presentation. Possible values for this
parameter are "Artin" and "BKL".
If the parameter Presentation is not used, a sequence containing
the generators for the presentation currently selected for B is returned.
Given a braid group B on n strings and an integer i, where 0 < |i| < n,
return the |i|-th Artin generator s_i, if i>0, or its
inverse s_{|i|}^{-1}, if i<0.
Given a braid group B on n strings and a tuple T = <r, t>, where
1 ≤|t| < |r| ≤n, return the BKL generator a|r|, |t|, if
r, t>0, or its inverse a|r|, |t| - 1 otherwise.
Given a braid group B on n strings and a sequence
[i1, ..., ik] of integers satisfying 0<|ij|<n (j=1, ..., k),
return the element of B given by the product
s_{|i_1|}^{sgn(i_1)}...s_{|i_k|}^{sgn(i_k)}.
Given a braid group B on n strings and a sequence
[T1, ..., Tk] of tuples satisfying Tj = <rj, tj>,
1 ≤|tj| < |rj| ≤n (j=1, ..., k),
return the element of B given by the product
a_{|r_1|,|t_1|}^{e_1}...a_{|r_k|,|t_k|}^{e_k}
where ej = 1 if rj, tj > 0 and ej = - 1 otherwise (j=1, ..., k).
B ! p : GrpBrd, GrpPermElt -> GrpBrdElt
Given a braid group B on n strings and a permutation p on n points,
return the simple element defined by p in the presentation
currently selected for B as new element of B.
Note that the result in general depends on the presentation
selected for B. Note
further that in the BKL presentation, only permutations which are products
of parallel descending cycles correspond to simple elements; attempting to
coerce an invalid permutation will result in a runtime error. The function
IsProductOfParallelDescendingCycles can be used to test
whether a given permutation corresponds to a BKL simple element.
Given a braid group B on n strings and a sequence [p1, ..., pk]
of permutations on n points, return the product c1 ... ck as
new element of B, where cj is the simple element defined by pj
in the presentation currently selected for B (j=1, ..., k).
Note that the result in general depends on the presentation
selected for B. Note
further that in the BKL presentation, only permutations which are products
of parallel descending cycles correspond to simple elements; attempting to
coerce a sequence containing an invalid permutation will result in a runtime
error. The function
IsProductOfParallelDescendingCycles can be used to test
whether a given permutation corresponds to a BKL simple element.
B ! T : GrpBrd, Tup -> GrpBrdElt
Given a braid group B on n strings and a tuple T = <s, l, S, r>, where
s is either the string "Artin" or the string "BKL", l and r are integers
and S is a sequence [p1, ..., pk] of permutations on n points, return
the product Dl c1 ... ck Dr as new element of B, where D is the
fundamental element and cj is the simple element defined by pj
(j=1, ..., k) in the presentation indicated by s.
Note that in the BKL presentation, only permutations which are products
of parallel descending cycles correspond to simple elements; if S
contains an invalid permutation, a runtime error will result. Whether the
elements of a given sequence S correspond to BKL simple elements can be
tested using the function
IsProductOfParallelDescendingCycles.
Given a permutation p on n points, return whether p is a product of
parallel descending cycles, that is, whether p defines a simple element
in the BKL monoid on n strings.
RandomCFP(B, r, s, m, n: parameters) : GrpBrd, RngIntElt, RngIntElt -> GrpBrdElt
Random(B: parameters) : GrpBrd -> GrpBrdElt
RandomCFP(B: parameters) : GrpBrd -> GrpBrdElt
Presentation: MonStgElt Default:
Given a braid group B and integers r, s, m, n, satisfying r≤s and
0≤m≤n, a pseudo-random element of B is constructed as follows.
Let D be the fundamental element and C the set of simple elements
for the presentation indicated by the parameter Presentation.
First, integers e∈[r, s] and l∈[m, n] are chosen using uniform
distributions on these sets. Then, for i=1, ..., l, ci ∈C is chosen
using a uniform distribution on C and the element De c1 ... cl
is returned.
If no value is given for the parameter Presentation, the presentation
selected for B is used.
The versions with a single argument are short for Random(B, 0, 0, 0, 42).
RandomWord(B, m, n: parameters) : GrpBrd, RngIntElt, RngIntElt -> GrpBrdElt
RandomWord(B: parameters) : GrpBrd -> GrpBrdElt
Presentation: MonStgElt Default:
Given a braid group B and two integers 0≤m≤n, Random(B, m, n)
returns a pseudo-random element of B constructed as follows. First, a length
l∈[m, n] is chosen using a uniform distribution. Then, for i=1, ..., l,
gi ∈X ∪X - 1 - {gi - 1 - 1} is chosen using a uniform
distribution on this set. Here, X is the set of generators of the
presentation indicated by the parameter Presentation and X - 1 is
the set of generator inverses.
If no value is given for the parameter Presentation, the presentation
selected for B is used.
The signature RandomWord(B) is short for RandomWord(B, 0, 42).
We construct the braid group B on 6 strings and the symmetric group S on 6
points.
> S := Sym(6);
> B := BraidGroup(6);
> B;
GrpBrd : B on 6 strings
By default, B is created using the Artin presentation.
> GetPresentation(B);
Artin
We now define the fundamental element with respect to the BKL presentation of
B and print this element with respect to the presentation currently used
for B, that is, with respect to the Artin presentation. Note that both
a word in the Artin generators and a representation of the element in terms
of Artin simple elements are printed.
> D_BKL := FundamentalElement(B : Presentation := "BKL");
> D_BKL;
B.5 * B.4 * B.3 * B.2 * B.1
<Artin, 0, [
(1, 6, 5, 4, 3, 2)
], 0>
> GetElementPrintFormat(B);
Both
We print the BKL generator a 3, 1.
> B.<3,1>;
B.2 * B.1 * B.2^-1
<Artin, 0, [
(1, 3, 2),
(1, 6)(2, 5, 3, 4)
], -1>
Next we change the format for printing elements of B using the function
SetElementPrintFormat so that only a representation in terms
of simple elements is printed.
> SetElementPrintFormat(~B, "CFP");
We now define and print several elements of B, illustrating the use of
some of the functions described in the previous section.
First we create a pseudo-random element of B as product of 3 random
simple elements for the Artin presentation.
> u := Random(B, 0, 0, 3, 3);
> u;
<Artin, 0, [
(1, 6)(3, 5, 4),
(1, 3)(2, 6)(4, 5),
(2, 3)
], 0>
Next we define an element of B by a product of simple elements for the
BKL presentation using the coercion operator ` !'.
Note that printing of this element is still done with respect to the Artin
presentation.
> v := B ! <"BKL", 0, [ S | (1,6)(3,5,4), (1,3)(4,5)], 0>;
> v;
<Artin, 0, [
(1, 6, 5, 4, 3, 2),
(1, 2, 6)(3, 5),
(2, 4, 5, 6),
(1, 6)(2, 4, 3, 5)
], -2>
Finally, we look at the simple elements defined by the permutations
p = (1, 3)(4, 2) and q = (1, 4, 3) on 6 points.
> p := S ! (1,3)(4,2);
> q := S ! (1,4,3);
Creating the simple elements for the Artin presentation defined by p
and q is straightforward using the coercion operator
` !'.
> p_Artin := B!p;
> p_Artin;
<Artin, 0, [
(1, 3)(2, 4)
], 0>
> q_Artin := B!q;
> q_Artin;
<Artin, 0, [
(1, 4, 3)
], 0>
We now change the presentation used for B to the BKL presentation. Note
that this also changes the presentation with respect to which elements are
printed.
> SetPresentation(~B, "BKL");
> GetPresentation(B);
BKL
The attempt to define a simple element for the BKL presentation using the
permutation p fails.
> p_BKL := B!p;
>> p_BKL := B!p;
^
Runtime error in '!': Illegal coercion
LHS: GrpBrd
RHS: GrpPermElt
We should have been more careful: using the function
IsProductOfParallelDescendingCycles we see that p is not
a product of parallel descending cycles and hence does not define a
simple element for the BKL presentation.
> IsProductOfParallelDescendingCycles(p);
false
q, on the other hand, does define a simple element for the BKL
presentation and we can coerce q to an element of B using the
operator ` !'.
> IsProductOfParallelDescendingCycles(q);
true
> q_BKL := B!q;
> q_BKL;
<BKL, 0, [
(1, 4, 3)
], 0>
Note however, that the simple element for the BKL presentation defined
by q and the simple element for the Artin presentation defined
by q are different elements of B! (The comparison operator
eq is described in Section
Boolean Predicates for Elements.)
> q_BKL eq q_Artin;
false
The representations of the Artin simple elements defined by p and q in
terms of BKL simple elements have no obvious connection to p and q,
respectively.
> p_Artin;
<BKL, 0, [
(1, 3, 2),
(2, 4, 3)
], 0>
> q_Artin;
<BKL, 0, [
(1, 4, 3, 2),
(2, 3)
], 0>
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|