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 \(\{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:

  • 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 matrix
  • normalized – 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 \(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:

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 matrix
  • reduced – 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. 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:

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 \(\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)
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', 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")
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', 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"])
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 \(B_n\).

OUTPUT:

  • a list of \(2n\) 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
sage.groups.braid.BraidGroup(n=None, names='s')

Construct a Braid Group

INPUT:

  • n – integer or None (default). The number of strands. If not specified the names 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 \(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
Element

alias of Braid

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:

A MappingClassGroupAction.

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:

\[\begin{split}x_j \cdot \sigma_i=\begin{cases} x_{j}\cdot x_{j+1}\cdot {x_j}^{-1} & \text{if $i=j$} \\ x_{j-1} & \text{if $i=j-1$} \\ x_{j} & \text{otherwise} \end{cases},\end{split}\]

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

Previous topic

Named Finitely Presented Groups

Next topic

Indexed Free Groups

This Page