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
AUTHOR:
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 , 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 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.
EXAMPLES:
sage: B = BraidGroup(4)
sage: B.inject_variables()
Defining s0, s1, s2
sage: b=s0*s1/s2/s1
sage: b.burau_matrix()
[ -t + 1 0 -t^2 + t t^2]
[ 1 0 0 0]
[ 0 0 1 0]
[ 0 t^-2 t^-1 - t^-2 1 - t^-1]
sage: s2.burau_matrix('x')
[ 1 0 0 0]
[ 0 1 0 0]
[ 0 0 -x + 1 x]
[ 0 0 1 0]
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 , 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()
sage: b.plot(color=["red", "blue", "red", "blue"])
sage: B.<s,t> = BraidGroup(3)
sage: b = t^-1*s^2
sage: b.plot(orientation="left-right", color="red")
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()
sage: b.plot3d(color="red")
sage: b.plot3d(color=["red", "blue", "red", "blue"])
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 .
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)
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 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 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 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 are the generators of the braid group on
strands, and
the generators of the free group of rank
.
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