Braid groups are implemented as a particular case of finitely presented groups, but with a lot of specific methods for braids.
A braid group can be created by giving the number of strands, and the name of the generators:
sage: BraidGroup(3)
Braid group on 3 strands
sage: BraidGroup(3,'a')
Braid group on 3 strands
sage: BraidGroup(3,'a').gens()
(a0, a1)
sage: BraidGroup(3,'a,b').gens()
(a, b)
The elements can be created by operating with the generators, or by passing a list with the indices of the letters to the group:
sage: B.<s0,s1,s2> = BraidGroup(4)
sage: s0*s1*s0
s0*s1*s0
sage: B([1,2,1])
s0*s1*s0
The mapping class action of the braid group over the free group is also implemented, see MappingClassGroupAction for an explanation. This action is left multiplication of a free group element by a braid:
sage: B.<b0,b1,b2> = BraidGroup()
sage: F.<f0,f1,f2,f3> = FreeGroup()
sage: B.strands() == F.rank() # necessary for the action to be defined
True
sage: f1 * b1
f1*f2*f1^-1
sage: f0 * b1
f0
sage: f1 * b1
f1*f2*f1^-1
sage: f1^-1 * b1
f1*f2^-1*f1^-1
AUTHORS:
Bases: sage.groups.finitely_presented.FinitelyPresentedGroupElement
Class that models elements of the braid group.
It is a particular case of element of a finitely presented group.
EXAMPLES:
sage: B.<s0,s1,s2> = BraidGroup(4)
sage: B
Braid group on 4 strands
sage: s0*s1/s2/s1
s0*s1*s2^-1*s1^-1
sage: B((1, 2, -3, -2))
s0*s1*s2^-1*s1^-1
Return the Lawence-Krammer-Bigelow representation matrix.
The matrix is expressed in the basis \(\{e_{i, j} \mid 1\leq i < j \leq n\}\), where the indices are ordered lexicographically. It is a matrix whose entries are in the ring of Laurent polynomials on the given variables. By default, the variables are 'x' and 'y'.
INPUT:
OUTPUT:
The matrix corresponding to the Lawence-Krammer-Bigelow representation of the braid.
EXAMPLES:
sage: B = BraidGroup(3)
sage: b = B([1, 2, 1])
sage: b.LKB_matrix()
[ 0 -x^4*y + x^3*y -x^4*y]
[ 0 -x^3*y 0]
[ -x^2*y x^3*y - x^2*y 0]
sage: c = B([2, 1, 2])
sage: c.LKB_matrix()
[ 0 -x^4*y + x^3*y -x^4*y]
[ 0 -x^3*y 0]
[ -x^2*y x^3*y - x^2*y 0]
REFERENCES:
[Bigelow] | Bigelow, Stephen J. The Lawrence-Krammer representation. arXiv:math/0204057v1 |
Return the Alexander polynomial of the closure of the braid.
INPUT:
OUTPUT:
The Alexander polynomial of the braid closure of the braid.
This is computed using the reduced Burau representation. The unnormalized Alexander polynomial is a Laurent polynomial, which is only well-defined up to multiplication by plus or minus times a power of \(t\).
We normalize the polynomial by dividing by the largest power of \(t\) and then if the resulting constant coefficient is negative, we multiply by \(-1\).
EXAMPLES:
We first construct the trefoil:
sage: B = BraidGroup(3)
sage: b = B([1,2,1,2])
sage: b.alexander_polynomial(normalized=False)
1 - t + t^2
sage: b.alexander_polynomial()
t^-2 - t^-1 + 1
Next we construct the figure 8 knot:
sage: b = B([-1,2,-1,2])
sage: b.alexander_polynomial(normalized=False)
-t^-2 + 3*t^-1 - 1
sage: b.alexander_polynomial()
t^-2 - 3*t^-1 + 1
Our last example is the Kinoshita-Terasaka knot:
sage: B = BraidGroup(4)
sage: b = B([1,1,1,3,3,2,-3,-1,-1,2,-1,-3,-2])
sage: b.alexander_polynomial(normalized=False)
-t^-1
sage: b.alexander_polynomial()
1
REFERENCES:
Return the Burau matrix of the braid.
INPUT:
OUTPUT:
The Burau matrix of the braid. It is a matrix whose entries are Laurent polynomials in the variable var. If reduced is True, return the matrix for the reduced Burau representation instead.
EXAMPLES:
sage: B = BraidGroup(4)
sage: B.inject_variables()
Defining s0, s1, s2
sage: b = s0*s1/s2/s1
sage: b.burau_matrix()
[ 1 - t 0 t - t^2 t^2]
[ 1 0 0 0]
[ 0 0 1 0]
[ 0 t^-2 -t^-2 + t^-1 -t^-1 + 1]
sage: s2.burau_matrix('x')
[ 1 0 0 0]
[ 0 1 0 0]
[ 0 0 1 - x x]
[ 0 0 1 0]
sage: s0.burau_matrix(reduced=True)
[-t 0 0]
[-t 1 0]
[-t 0 1]
REFERENCES:
Return the left normal form of the braid.
OUTPUT:
A tuple of braid generators in the left normal form. The first element is a power of \(\Delta\), and the rest are permutation braids.
EXAMPLES:
sage: B = BraidGroup(4)
sage: b = B([1, 2, 3, -1, 2, -3])
sage: b.left_normal_form()
(s0^-1*s1^-1*s2^-1*s0^-1*s1^-1*s0^-1, s0*s1*s2*s1*s0, s0*s2*s1)
sage: c = B([1])
sage: c.left_normal_form()
(1, s0)
Return the permutation induced by the braid in its strands.
OUTPUT:
A permutation.
EXAMPLES:
sage: B.<s0,s1,s2> = BraidGroup()
sage: b = s0*s1/s2/s1
sage: b.permutation()
[4, 1, 3, 2]
sage: b.permutation().cycle_string()
'(1,4,2)'
Plot the braid
The following options are available:
color – (default: 'rainbow') the color of the strands. Possible values are:
- 'rainbow', uses rainbow() according to the number of strands.
- a valid color name for bezier_path() and line(). Used for all strands.
- a list or a tuple of colors for each individual strand.
orientation – (default: 'bottom-top') determines how the braid is printed. The possible values are:
- 'bottom-top', the braid is printed from bottom to top
- 'top-bottom', the braid is printed from top to bottom
- 'left-right', the braid is printed from left to right
gap – floating point number (default: 0.05). determines the size of the gap left when a strand goes under another.
aspect_ratio – floating point number (default: 1). The aspect ratio.
**kwds – other keyword options that are passed to bezier_path() and line().
EXAMPLES:
sage: B = BraidGroup(4, 's')
sage: b = B([1, 2, 3, 1, 2, 1])
sage: b.plot()
Graphics object consisting of 30 graphics primitives
sage: b.plot(color=["red", "blue", "red", "blue"])
Graphics object consisting of 30 graphics primitives
sage: B.<s,t> = BraidGroup(3)
sage: b = t^-1*s^2
sage: b.plot(orientation="left-right", color="red")
Graphics object consisting of 12 graphics primitives
Plots the braid in 3d.
The following option is available:
color – (default: 'rainbow') the color of the strands. Possible values are:
- 'rainbow', uses rainbow() according to the number of strands.
- a valid color name for bezier3d(). Used for all strands.
- a list or a tuple of colors for each individual strand.
EXAMPLES:
sage: B = BraidGroup(4, 's')
sage: b = B([1, 2, 3, 1, 2, 1])
sage: b.plot3d()
Graphics3d Object
sage: b.plot3d(color="red")
Graphics3d Object
sage: b.plot3d(color=["red", "blue", "red", "blue"])
Graphics3d Object
Return the number of strands in the braid.
EXAMPLES:
sage: B = BraidGroup(4)
sage: b = B([1, 2, -1, 3, -2])
sage: b.strands()
4
Return the tropical coordinates of self in the braid group \(B_n\).
OUTPUT:
EXAMPLES:
sage: B = BraidGroup(3)
sage: b = B([1])
sage: tc = b.tropical_coordinates(); tc
[1, 0, 0, 2, 0, 1]
sage: tc[0].parent()
Tropical semiring over Integer Ring
sage: b = B([-2, -2, -1, -1, 2, 2, 1, 1])
sage: b.tropical_coordinates()
[1, -19, -12, 9, 0, 13]
REFERENCES:
[Dynnikov07] | I. Dynnikov and B. Wiest, On the complexity of braids, J. Europ. Math. Soc. 9 (2007) |
[Dehornoy] | P. Dehornoy, Le probleme d’isotopie des tresses, in lecons de mathematiques d’aujourd’hui vol. 4 |
Construct a Braid Group
INPUT:
EXAMPLES:
sage: B.<a,b> = BraidGroup(); B
Braid group on 3 strands
sage: H = BraidGroup('a, b')
sage: B is H
True
sage: BraidGroup(3)
Braid group on 3 strands
The entry can be either a string with the names of the generators, or the number of generators and the prefix of the names to be given. The default prefix is 's'
sage: B=BraidGroup(3); B.generators()
(s0, s1)
sage: BraidGroup(3, 'g').generators()
(g0, g1)
Since the word problem for the braid groups is solvable, their Cayley graph can be localy obtained as follows (see trac ticket #16059):
sage: def ball(group, radius):
....: ret = set()
....: ret.add(group.one())
....: for length in range(1, radius):
....: for w in Words(alphabet=group.gens(), length=length):
....: ret.add(prod(w))
....: return ret
sage: B = BraidGroup(4)
sage: GB = B.cayley_graph(elements=ball(B, 4), generators=B.gens()); GB
Digraph on 31 vertices
Since the braid group has nontrivial relations, this graph contains less vertices than the one associated to the free group (which is a tree):
sage: F = FreeGroup(3)
sage: GF = F.cayley_graph(elements=ball(F, 4), generators=F.gens()); GF
Digraph on 40 vertices
TESTS:
sage: G1 = BraidGroup(3, 'a,b')
sage: G2 = BraidGroup('a,b')
sage: G3.<a,b> = BraidGroup()
sage: G1 is G2, G2 is G3
(True, True)
Bases: sage.groups.finitely_presented.FinitelyPresentedGroup
The braid group on \(n\) strands.
EXAMPLES:
sage: B1 = BraidGroup(5)
sage: B1
Braid group on 5 strands
sage: B2 = BraidGroup(3)
sage: B1==B2
False
sage: B2 is BraidGroup(3)
True
Return an element of the braid group.
This is used both for illustration and testing purposes.
EXAMPLES:
sage: B=BraidGroup(2)
sage: B.an_element()
s
Return an isomorphic permutation group.
OUTPUT:
Raises a ValueError error since braid groups are infinite.
TESTS:
sage: B = BraidGroup(4, 'g')
sage: B.as_permutation_group()
Traceback (most recent call last):
...
ValueError: the group is infinite
Return the number of group elements.
OUTPUT:
Infinity.
TESTS:
sage: B1 = BraidGroup(5)
sage: B1.cardinality()
+Infinity
Return the action of self in the free group F as mapping class group.
This action corresponds to the action of the braid over the punctured disk, whose fundamental group is the free group on as many generators as strands.
In Sage, this action is the result of multiplying a free group element with a braid. So you generally do not have to construct this action yourself.
OUTPUT:
EXAMPLES
sage: B = BraidGroup(3)
sage: B.inject_variables()
Defining s0, s1
sage: F.<a,b,c> = FreeGroup(3)
sage: A = B.mapping_class_action(F)
sage: A(a,s0)
a*b*a^-1
sage: a * s0 # simpler notation
a*b*a^-1
Return the number of group elements.
OUTPUT:
Infinity.
TESTS:
sage: B1 = BraidGroup(5)
sage: B1.cardinality()
+Infinity
Return a list of some elements of the braid group.
This is used both for illustration and testing purposes.
EXAMPLES:
sage: B=BraidGroup(3)
sage: B.some_elements()
[s0, s0*s1, (s0*s1)^3]
Return the number of strands.
OUTPUT:
Integer.
EXAMPLES:
sage: B = BraidGroup(4)
sage: B.strands()
4
Bases: sage.categories.action.Action
The action of the braid group the free group as the mapping class group of the punctured disk.
That is, this action is the action of the braid over the punctured disk, whose fundamental group is the free group on as many generators as strands.
This action is defined as follows:
where \(\sigma_i\) are the generators of the braid group on \(n\) strands, and \(x_j\) the generators of the free group of rank \(n\).
You should left multiplication of the free group element by the braid to compute the action. Alternatively, use the mapping_class_action() method of the braid group to constuct this action.
EXAMPLES:
sage: B.<s0,s1,s2> = BraidGroup(4)
sage: F.<x0,x1,x2,x3> = FreeGroup(4)
sage: x0 * s1
x0
sage: x1 * s1
x1*x2*x1^-1
sage: x1^-1 * s1
x1*x2^-1*x1^-1
sage: A = B.mapping_class_action(F)
sage: A
Right action by Braid group on 4 strands on Free Group on generators {x0, x1, x2, x3}
sage: A(x0, s1)
x0
sage: A(x1, s1)
x1*x2*x1^-1
sage: A(x1^-1, s1)
x1*x2^-1*x1^-1