This section describes the facilities for creating elements of a braid group.
Given a braid group B, return a representative of B.
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).
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.
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.
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).
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 stringsBy default, B is created using the Artin presentation.
> GetPresentation(B); ArtinWe 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 a3, 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); BKLThe 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); falseq, 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; falseThe 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>