Braid groups¶
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:
- Miguel Angel Marco Buzunariz
- Volker Braun
- Robert Lipshitz
- Thierry Monteil: add a
__hash__
method consistent with the word problem to ensure correct Cayley graph computations.
-
class
sage.groups.braid.
Braid
(parent, x, check=True)¶ 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
-
LKB_matrix
(variables='x, y')¶ 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:
variables
– string (default:'x,y'
). A string containing the names of the variables, separated by a comma.
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
-
alexander_polynomial
(var='t', normalized=True)¶ Return the Alexander polynomial of the closure of the braid.
INPUT:
var
– string (default:'t'
); the name of the variable in the entries of the matrixnormalized
– boolean (default:True
); whether to return the normalized Alexander polynomial
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
.
We normalize the polynomial by dividing by the largest power of
and then if the resulting constant coefficient is negative, we multiply by
.
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:
-
burau_matrix
(var='t', reduced=False)¶ Return the Burau matrix of the braid.
INPUT:
var
– string (default:'t'
); the name of the variable in the entries of the matrixreduced
– boolean (default:False
); whether to return the reduced or unreduced Burau representation
OUTPUT:
The Burau matrix of the braid. It is a matrix whose entries are Laurent polynomials in the variable
var
. Ifreduced
isTrue
, 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:
-
left_normal_form
()¶ 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)
-
permutation
()¶ 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
(color='rainbow', orientation='bottom-top', gap=0.05, aspect_ratio=1, axes=False, **kwds)¶ Plot the braid
The following options are available:
color
– (default:'rainbow'
) the color of the strands. Possible values are:'rainbow'
, usesrainbow()
according to the number of strands.- a valid color name for
bezier_path()
andline()
. 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 tobezier_path()
andline()
.
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
-
plot3d
(color='rainbow')¶ Plots the braid in 3d.
The following option is available:
color
– (default:'rainbow'
) the color of the strands. Possible values are:'rainbow'
, usesrainbow()
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
-
strands
()¶ 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
-
tropical_coordinates
()¶ Return the tropical coordinates of
self
in the braid group.
OUTPUT:
- a list of
tropical integers
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 - a list of
-
-
sage.groups.braid.
BraidGroup
(n=None, names='s')¶ Construct a Braid Group
INPUT:
n
– integer orNone
(default). The number of strands. If not specified thenames
are counted and the group is assumed to have one more strand than generators.names
– string or list/tuple/iterable of strings (default:'x'
). The generator names or name prefix.
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)
-
class
sage.groups.braid.
BraidGroup_class
(names)¶ 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
-
an_element
()¶ 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
-
as_permutation_group
()¶ 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
-
cardinality
()¶ Return the number of group elements.
OUTPUT:
Infinity.
TESTS:
sage: B1 = BraidGroup(5) sage: B1.cardinality() +Infinity
-
mapping_class_action
(F)¶ 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
-
order
()¶ Return the number of group elements.
OUTPUT:
Infinity.
TESTS:
sage: B1 = BraidGroup(5) sage: B1.cardinality() +Infinity
-
some_elements
()¶ 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]
-
strands
()¶ Return the number of strands.
OUTPUT:
Integer.
EXAMPLES:
sage: B = BraidGroup(4) sage: B.strands() 4
-
-
class
sage.groups.braid.
MappingClassGroupAction
(G, M, is_left=0)¶ 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