passagemath-libbraiding 10.6.31rc1__cp312-abi3-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

passagemath_libbraiding-10.6.31rc1.dist-info/METADATA

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: passagemath-libbraiding
+Version: 10.6.31rc1
+Summary: passagemath: Braid computations with libbraiding
+Author-email: The Sage Developers <sage-support@googlegroups.com>
+Maintainer: Matthias Köppe, passagemath contributors
+License-Expression: GPL-2.0-or-later
+Project-URL: release notes, https://github.com/passagemath/passagemath/releases
+Project-URL: repo (upstream), https://github.com/sagemath/sage
+Project-URL: repo, https://github.com/passagemath/passagemath
+Project-URL: documentation, https://passagemath.org/docs/latest
+Project-URL: homepage (upstream), https://www.sagemath.org
+Project-URL: discourse, https://passagemath.discourse.group
+Project-URL: tracker (upstream), https://github.com/sagemath/sage/issues
+Project-URL: tracker, https://github.com/passagemath/passagemath/issues
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: <3.14,>=3.10
+Description-Content-Type: text/x-rst
+Requires-Dist: passagemath-objects==10.6.31rc1
+Requires-Dist: memory_allocator
+Requires-Dist: cysignals<1.12.4; sys_platform == "win32"
+Requires-Dist: cysignals!=1.12.0,>=1.11.2
+Provides-Extra: test
+Requires-Dist: passagemath-combinat; extra == "test"
+Requires-Dist: passagemath-graphs; extra == "test"
+Requires-Dist: passagemath-groups; extra == "test"
+Requires-Dist: passagemath-repl; extra == "test"
+Requires-Dist: passagemath-schemes; extra == "test"
+
+=============================================================================
+ passagemath: Braid computations with libbraiding
+=============================================================================
+
+`passagemath <https://github.com/passagemath/passagemath>`__ is open
+source mathematical software in Python, released under the GNU General
+Public Licence GPLv2+.
+
+It is a fork of `SageMath <https://www.sagemath.org/>`__, which has been
+developed 2005-2025 under the motto “Creating a Viable Open Source
+Alternative to Magma, Maple, Mathematica, and MATLAB”.
+
+The passagemath fork uses the motto "Creating a Free Passage Between the
+Scientific Python Ecosystem and Mathematical Software Communities."
+It was created in October 2024 with the following goals:
+
+-  providing modularized installation with pip,
+-  establishing first-class membership in the scientific Python
+   ecosystem,
+-  giving `clear attribution of upstream
+   projects <https://groups.google.com/g/sage-devel/c/6HO1HEtL1Fs/m/G002rPGpAAAJ>`__,
+-  providing independently usable Python interfaces to upstream
+   libraries,
+-  offering `platform portability and integration testing
+   services <https://github.com/passagemath/passagemath/issues/704>`__
+   to upstream projects,
+-  inviting collaborations with upstream projects,
+-  `building a professional, respectful, inclusive
+   community <https://groups.google.com/g/sage-devel/c/xBzaINHWwUQ>`__,
+-  `empowering Sage users to participate in the scientific Python ecosystem
+   <https://github.com/passagemath/passagemath/issues/248>`__ by publishing packages,
+-  developing a port to `Pyodide <https://pyodide.org/en/stable/>`__ for
+   serverless deployment with Javascript,
+-  developing a native Windows port.
+
+`Full documentation <https://passagemath.org/docs/latest/html/en/index.html>`__ is
+available online.
+
+passagemath attempts to support and provides binary wheels suitable for
+all major Linux distributions and recent versions of macOS.
+
+Binary wheels for native Windows (x86_64) are are available for a subset of
+the passagemath distributions. Use of the full functionality of passagemath
+on Windows currently requires the use of Windows Subsystem for Linux (WSL)
+or virtualization.
+
+The supported Python versions in the passagemath 10.6.x series are 3.10.x-3.13.x.
+
+
+About this pip-installable distribution package
+-----------------------------------------------
+
+This pip-installable source distribution ``passagemath-libbraiding`` provides
+an interface to `libbraiding <https://github.com/miguelmarco/libbraiding>`_,
+a library to compute several properties of braids,
+including centralizer and conjugacy check.
+
+
+What is included
+----------------
+
+* `sage.libs.braiding <https://github.com/passagemath/passagemath/blob/main/src/sage/libs/braiding.pyx>`_
+
+
+Examples
+--------
+
+::
+
+    $ pipx run --pip-args="--prefer-binary" --spec "passagemath-libbraiding[test]" ipython
+
+    In [1]: from sage.all__sagemath_libbraiding import *
+
+    In [2]: from sage.libs.braiding import conjugatingbraid
+
+    In [3]: B = BraidGroup(3); b = B([1,2,1,-2]); c = B([1,2])
+
+    In [4]: conjugatingbraid(b,c)
+    Out[4]: [[0], [2]]
+
+
+Development
+-----------
+
+::
+
+    $ git clone --origin passagemath https://github.com/passagemath/passagemath.git
+    $ cd passagemath
+    passagemath $ ./bootstrap
+    passagemath $ python3 -m venv libbraiding-venv
+    passagemath $ source libbraiding-venv/bin/activate
+    (libbraiding-venv) passagemath $ pip install -v -e pkgs/sagemath-libbraiding

passagemath_libbraiding-10.6.31rc1.dist-info/RECORD

@@ -0,0 +1,9 @@
+passagemath_libbraiding.libs/libbraiding-3c0a272c.so.0.0.0,sha256=74Vwc4d2TjyRRqBXVls4kj5AQmp4DkvwMXxzqb8PwBs,3631153
+sage/all__sagemath_libbraiding.py,sha256=YFtacYzpNCVWMxSKZW0rwFrLVGiuBZ-eXSEcwouWpG4,350
+sage/libs/all__sagemath_libbraiding.py,sha256=HzvyH9JZ1Fjh65Qx_jwx_UD5XSJg2iOTg7L5ajVVYvs,50
+sage/libs/braiding.abi3.so,sha256=agXQk6ixsR7stFDFX6mjlDIywnaCrle27Dy84MFmQJA,1657609
+sage/libs/braiding.pyx,sha256=xJfL8rQhdliD5Z4PyZybDQzuVsr8bbMaUzUTwl0eIuc,14059
+passagemath_libbraiding-10.6.31rc1.dist-info/METADATA,sha256=K52O-8MbTDHE-CXhNI7mH8f9ZjPBzPCorzXVDp3l6xQ,5515
+passagemath_libbraiding-10.6.31rc1.dist-info/WHEEL,sha256=XFz5rpESoSYakbZNGVncA1t1wAH4SxtceSkss2HSul4,150
+passagemath_libbraiding-10.6.31rc1.dist-info/top_level.txt,sha256=Kmzulf9WsphADFQuqgvdy5mvTLDj_V2zkFHU2s3UXos,6
+passagemath_libbraiding-10.6.31rc1.dist-info/RECORD,,

passagemath_libbraiding-10.6.31rc1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp312-abi3-manylinux_2_24_x86_64
+Tag: cp312-abi3-manylinux_2_28_x86_64
+

passagemath_libbraiding-10.6.31rc1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+
+sage

sage/all__sagemath_libbraiding.py

@@ -0,0 +1,19 @@
+# sage_setup: distribution = sagemath-libbraiding
+# delvewheel: patch
+
+from sage.all__sagemath_objects import *
+
+try:
+    from sage.all__sagemath_groups import *
+except ImportError:
+    pass
+
+try:
+    from sage.all__sagemath_graphs import *
+except ImportError:
+    pass
+
+try:
+    from sage.all__sagemath_schemes import *
+except ImportError:
+    pass

sage/libs/all__sagemath_libbraiding.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-libbraiding

sage/libs/braiding.pyx

@@ -0,0 +1,550 @@
+# sage_setup: distribution = sagemath-libbraiding
+# distutils: libraries = braiding
+# distutils: language = c++
+# distutils: extra_compile_args = -std=c++11
+r"""
+Cython wrapper for the libbraiding library.
+
+The libbraiding library is a modification of the braiding program
+by Juan Gonzalez-Meneses (https://github.com/jeanluct/cbraid)
+to expose the functions as a C++ library instead of an interactive
+program.
+
+Braids are returned in left normal form as a list of lists. The
+first list contains only an integer, representing the power of
+`\Delta`. The subsequent lists are the Tietze lists of the elementary
+permutation braids.
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2016 Miguel Marco  <mmarco@unizar.es>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at youroption) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+
+from cysignals.signals cimport sig_on, sig_off
+
+from libcpp.list cimport list
+
+
+cdef extern from "braiding.h" namespace "Braiding":
+    list[list[int]] ConjugatingBraid (int n, list[int] word, list[int] word2)
+    list[list[int]] LeftNormalForm (int n, list[int] word)
+    list[list[int]] RightNormalForm (int n, list[int] word)
+    list[list[int]] GreatestCommonDivisor(int n, list[int] word1, list[int] word2)
+    list[list[int]] LeastCommonMultiple(int n, list[int] word1, list[int] word2)
+    list[list[list[int]]] CentralizerGenerators(int n, list[int] word)
+    list[list[list[int]]] SuperSummitSet(int n, list[int] word)
+    list[list[list[list[int]]]] UltraSummitSet(int n, list[int] word)
+    int thurstontype(int n, list[int] word)
+    int Rigidity_ext(int n, list[int] word)
+    list[list[list[list[int]]]] SlidingCircuits(int n, list[int] word)
+    list[list[list[int]]] SendToSSS(int n, list[int] word)
+    list[list[list[int]]] SendToUSS(int n, list[int] word)
+    list[list[list[int]]] SendToSC(int n, list[int] word)
+    list[list[list[int]]] Trajectory(int n, list[int] word)
+    list[list[list[list[int]]]] CyclicSlidings(int n, list[int] word)
+
+
+def conjugatingbraid(braid1, braid2):
+    r"""
+    Return a braid that conjugates ``braid1`` to ``braid2`` if
+    such a braid exists.
+
+    INPUT:
+
+    - ``braid1`` -- the braid to be conjugated
+    - ``braid2`` -- the braid to conjugate to
+
+    OUTPUT:
+
+    The list of lists that represent a conjugating braid. If the input braids
+    are not conjugate, an empty list is returned.
+
+    EXAMPLES::
+
+        sage: from sage.libs.braiding import conjugatingbraid
+        sage: B = BraidGroup(3)
+        sage: b = B([1,2,1,-2])
+        sage: c = B([1,2])
+        sage: conjugatingbraid(b,c)
+        [[0], [2]]
+    """
+    nstrands = max(braid1.parent().strands(), braid2.parent().strands())
+    l1 = braid1.Tietze()
+    l2 = braid2.Tietze()
+    sig_on()
+    cdef list[list[int]] rop = ConjugatingBraid(nstrands, l1, l2)
+    sig_off()
+    return rop
+
+
+def leftnormalform(braid):
+    r"""
+    Return the left normal form of a braid.
+
+    INPUT:
+
+    - ``braid`` -- a braid
+
+    OUTPUT:
+
+    A list of lists with the left normal form. The first list contains
+    the power of `\Delta`. The subsequent lists are the elementary
+    permutation braids.
+
+    EXAMPLES::
+
+        sage: from sage.libs.braiding import leftnormalform
+        sage: B = BraidGroup(3)
+        sage: b = B([1,2,1,-2])
+        sage: leftnormalform(b)
+        [[0], [2, 1]]
+    """
+    nstrands = braid.parent().strands()
+    l1 = braid.Tietze()
+    sig_on()
+    cdef list[list[int]] rop = LeftNormalForm(nstrands, l1)
+    sig_off()
+    return rop
+
+
+def rightnormalform(braid):
+    r"""
+    Return the right normal form of a braid.
+
+    INPUT:
+
+    - ``braid`` -- a braid
+
+    OUTPUT:
+
+    A list of lists with the right normal form. The first list contains
+    the power of `\Delta`. The subsequent lists are the elementary
+    permutation braids.
+
+    EXAMPLES::
+
+        sage: from sage.libs.braiding import rightnormalform
+        sage: B = BraidGroup(3)
+        sage: b = B([1,2,1,-2])
+        sage: rightnormalform(b)
+        [[2, 1], [0]]
+    """
+    nstrands = braid.parent().strands()
+    l1 = braid.Tietze()
+    sig_on()
+    cdef list[list[int]] rop = RightNormalForm(nstrands, l1)
+    sig_off()
+    return rop
+
+
+def greatestcommondivisor(braid1, braid2):
+    r"""
+    Return the greatest common divisor of two braids.
+
+    INPUT:
+
+    - ``braid1`` -- a braid
+    - ``braid2`` -- a braid
+
+    OUTPUT: list of lists representing the gcd of ``braid1`` and ``braid2``
+
+    EXAMPLES::
+
+        sage: from sage.libs.braiding import greatestcommondivisor
+        sage: B = BraidGroup(3)
+        sage: b1 = B([1, 2, -1])
+        sage: b2 = B([2, 2, 2])
+        sage: greatestcommondivisor(b1, b2)
+        [[-1], [2, 1]]
+    """
+    nstrands = max(braid1.parent().strands(), braid2.parent().strands())
+    l1 = braid1.Tietze()
+    l2 = braid2.Tietze()
+    sig_on()
+    cdef list[list[int]] rop = GreatestCommonDivisor(nstrands, l1, l2)
+    sig_off()
+    return rop
+
+
+def leastcommonmultiple(braid1, braid2):
+    r"""
+    Return the least common multiple of two braids.
+
+    INPUT:
+
+    - ``braid1`` -- a braid
+    - ``braid2`` -- a braid
+
+    OUTPUT: list of lists representing the lcm of ``braid1`` and ``braid2``
+
+    EXAMPLES::
+
+        sage: from sage.libs.braiding import leastcommonmultiple
+        sage: B = BraidGroup(3)
+        sage: b1 = B([1, 2, -1])
+        sage: b2 = B([2, 2, 2])
+        sage: leastcommonmultiple(b1, b2)
+        [[1], [1], [1]]
+    """
+    nstrands = max(braid1.parent().strands(), braid2.parent().strands())
+    l1 = braid1.Tietze()
+    l2 = braid2.Tietze()
+    sig_on()
+    cdef list[list[int]] rop = LeastCommonMultiple(nstrands, l1, l2)
+    sig_off()
+    return rop
+
+
+def centralizer(braid):
+    r"""
+    Return a list of generators of the centralizer of a braid.
+
+    INPUT:
+
+    - ``braid`` -- a braid
+
+    OUTPUT:
+
+    A list of lists representing the generators of the centralizer
+    of ``braid``.
+
+    EXAMPLES::
+
+        sage: from sage.libs.braiding import centralizer
+        sage: B = BraidGroup(3)
+        sage: b = B([1,2,-1])
+        sage: centralizer(b)
+        [[[-1], [2, 1], [1, 2]], [[0], [1], [1, 2], [2]]]
+    """
+    nstrands = braid.parent().strands()
+    lnf = leftnormalform(braid)
+    if len(lnf) == 1: # (lib)braiding crashes when the input is a power of Delta.
+        if lnf[0][0] % 2 == 0:
+            return [[[0], [i+1]] for i in range(nstrands)]
+        elif nstrands % 2:
+            return [[[0], [i+1, nstrands - i -1]] for i in range(nstrands//2)]
+        else:
+            return [[[0], [i+1, nstrands - i -1]] for i in range(nstrands//2-1)] + [[[0], [nstrands//2]]]
+    l = braid.Tietze()
+    sig_on()
+    cdef list[list[list[int]]] rop = CentralizerGenerators(nstrands, l)
+    sig_off()
+    return rop
+
+
+def supersummitset(braid):
+    r"""
+    Return a list with the super-summit-set of a braid.
+
+    INPUT:
+
+    - ``braid`` -- a braid
+
+    OUTPUT: list of lists representing the super summit set of ``braid``
+
+    EXAMPLES::
+
+        sage: from sage.libs.braiding import supersummitset
+        sage: B = BraidGroup(3)
+        sage: b = B([1,2,-1])
+        sage: supersummitset(b)
+        [[[0], [2]], [[0], [1]]]
+    """
+    nstrands = braid.parent().strands()
+    l = braid.Tietze()
+    sig_on()
+    cdef list[list[list[int]]] rop = SuperSummitSet(nstrands, l)
+    sig_off()
+    return rop
+
+
+def ultrasummitset(braid):
+    r"""
+    Return a list with the orbits forming the ultra-summit-set of the braid.
+
+    INPUT:
+
+    - ``braid`` -- a braid
+
+    OUTPUT:
+
+    A list of lists of lists representing the orbits of the ultra summit
+    set of ``braid``.
+
+    EXAMPLES::
+
+        sage: from sage.libs.braiding import ultrasummitset
+        sage: B = BraidGroup(3)
+        sage: b = B([1,2,-1])
+        sage: ultrasummitset(b)
+        [[[[0], [2]]], [[[0], [1]]]]
+    """
+    nstrands = braid.parent().strands()
+    l = braid.Tietze()
+    sig_on()
+    cdef list[list[list[list[int]]]] rop = UltraSummitSet(nstrands, l)
+    sig_off()
+    return rop
+
+
+def thurston_type(braid):
+    r"""
+    Return the Thurston type of the braid.
+
+    INPUT:
+
+    - ``braid`` -- a braid
+
+    OUTPUT:
+
+    One of ``'periodic'``, ``'reducible'`` or ``'pseudo-anosov'``.
+
+    EXAMPLES::
+
+        sage: from sage.libs.braiding import thurston_type
+        sage: B = BraidGroup(3)
+        sage: b = B([1,2,-1])
+        sage: thurston_type(b)
+        'reducible'
+        sage: c = B([1,2,1])
+        sage: thurston_type(c)
+        'periodic'
+        sage: d = B([1,1,1,2,2])
+        sage: thurston_type(d)
+        'pseudo-anosov'
+    """
+    nstrands = braid.parent().strands()
+    l = braid.Tietze()
+    sig_on()
+    cdef int i = thurstontype(nstrands, l)
+    sig_off()
+    if i == 1:
+        return 'periodic'
+    if i == 2:
+        return 'reducible'
+    if i == 3:
+        return 'pseudo-anosov'
+
+
+def rigidity(braid):
+    r"""
+    Return the rigidity of the braid.
+
+    INPUT:
+
+    - ``braid`` -- a braid
+
+    OUTPUT: the rigidity of the braid
+
+    EXAMPLES::
+
+        sage: from sage.libs.braiding import rigidity
+        sage: B = BraidGroup(3)
+        sage: c = B([1,1,1,2,2])
+        sage: rigidity(c)
+        3
+    """
+    nstrands = braid.parent().strands()
+    l = braid.Tietze()
+    sig_on()
+    cdef int i = Rigidity_ext(nstrands, l)
+    sig_off()
+    return i
+
+
+def sliding_circuits(braid):
+    r"""
+    Return the set of sliding circuits of the braid.
+
+    INPUT:
+
+    - ``braid`` -- a braid
+
+    OUTPUT:
+
+    A list with the sliding circuits of ``braid``. Each sliding circuit
+    is a list of braids.
+
+    EXAMPLES::
+
+        sage: from sage.libs.braiding import sliding_circuits
+        sage: B = BraidGroup(3)
+        sage: c = B([1,1,1,2,2])
+        sage: sliding_circuits(c)
+        [[[[0], [1], [1, 2], [2, 1]]],
+        [[[0], [2], [2, 1], [1, 2]]],
+        [[[0], [1, 2], [2, 1], [1]]],
+        [[[0], [2, 1], [1, 2], [2]]],
+        [[[0], [1, 2], [2], [2, 1]]],
+        [[[0], [2, 1], [1], [1, 2]]]]
+    """
+    nstrands = braid.parent().strands()
+    l = braid.Tietze()
+    sig_on()
+    cdef list[list[list[list[int]]]] rop = SlidingCircuits(nstrands, l)
+    sig_off()
+    return rop
+
+
+def send_to_sss(braid):
+    r"""
+    Return an element of the braid's super summit set and the conjugating braid.
+
+    INPUT:
+
+    - ``braid`` -- a braid
+
+    OUTPUT:
+
+    A list with two braids, the first one is an element of ``braid`` super summit
+    set, the second one is the corresponding conjugating braid.
+
+    EXAMPLES::
+
+        sage: from sage.libs.braiding import send_to_sss
+        sage: B = BraidGroup(4)
+        sage: d = B([1, 2, 1, 2, 3, -1, 2,- 3])
+        sage: send_to_sss(d)
+        [[[0], [1, 2, 1, 3]], [[-1], [1, 2, 3, 2]]]
+
+    """
+    nstrands = braid.parent().strands()
+    l = braid.Tietze()
+    sig_on()
+    cdef list[list[list[int]]] rop = SendToSSS(nstrands, l)
+    sig_off()
+    return rop
+
+
+def send_to_uss(braid):
+    r"""
+    Return an element of the braid's ultra summit set and the conjugating braid.
+
+    INPUT:
+
+    - ``braid`` -- a braid
+
+    OUTPUT:
+
+    A list with two braids, the first one is an element of ``braid`` ultra summit
+    set, the second one is the corresponding conjugating braid.
+
+    EXAMPLES::
+
+        sage: from sage.libs.braiding import send_to_uss
+        sage: B = BraidGroup(4)
+        sage: d = B([1, 2, 1, 2, 3, -1, 2,- 1])
+        sage: send_to_uss(d)
+        [[[0], [1, 2, 3, 2]], [[0], [1]]]
+
+    """
+    nstrands = braid.parent().strands()
+    l = braid.Tietze()
+    sig_on()
+    cdef list[list[list[int]]] rop = SendToUSS(nstrands, l)
+    sig_off()
+    return rop
+
+
+def send_to_sc(braid):
+    r"""
+    Return an element of the braid's sliding circuits and the conjugating braid.
+
+    INPUT:
+
+    - ``braid`` -- a braid
+
+    OUTPUT:
+
+    A list with two braids, the first one is an element of ``braid`` sliding
+    circuits, the second one is the corresponding conjugating braid.
+
+    EXAMPLES::
+
+        sage: from sage.libs.braiding import send_to_sc
+        sage: B = BraidGroup(4)
+        sage: d = B([1, 2, 1, 2, 3, -1, 2, 2])
+        sage: send_to_sc(d)
+        [[[0], [1, 2, 3, 2], [2, 1]], [[0], [1]]]
+
+
+    """
+    nstrands = braid.parent().strands()
+    l = braid.Tietze()
+    sig_on()
+    cdef list[list[list[int]]] rop = SendToSC(nstrands, l)
+    sig_off()
+    return rop
+
+
+def trajectory(braid):
+    r"""
+    Return the braid's trajectory.
+
+    INPUT:
+
+    - ``braid`` -- a braid
+
+    OUTPUT:
+
+    A list of braids, formed by the ``braid```trajectory.
+
+    EXAMPLES::
+
+        sage: from sage.libs.braiding import trajectory
+        sage: B = BraidGroup(4)
+        sage: d = B([1, 2, 1, 2, 3, -1, 2, 2])
+        sage: trajectory(d)
+        [[[0], [1, 3], [1, 2, 3, 2]],
+         [[0], [1, 2, 3, 2, 1], [3]],
+         [[0], [1, 2, 3, 2], [2, 1]],
+         [[0], [2, 1, 3], [1, 2, 3]]]
+
+
+    """
+    nstrands = braid.parent().strands()
+    l = braid.Tietze()
+    sig_on()
+    cdef list[list[list[int]]] rop = Trajectory(nstrands, l)
+    sig_off()
+    return rop
+
+
+def cyclic_slidings(braid):
+    r"""
+    Return the cyclic slidings of the braid.
+
+    INPUT:
+
+    - ``braid`` -- a braid
+
+    OUTPUT:
+
+    A list of lists of braids, given by the input's cyclic slidings.
+
+    EXAMPLES::
+
+        sage: from sage.libs.braiding import cyclic_slidings
+        sage: B = BraidGroup(4)
+        sage: d = B([1, 2, 1, 2, 3, -1, 2, 2])
+        sage: cyclic_slidings(d)
+        [[[[0], [1, 2, 3, 2], [2, 1]],
+          [[0], [1, 2, 3, 2, 1], [3]],
+          [[0], [2, 1, 3], [1, 2, 3]]],
+         [[[0], [1, 3, 2, 1], [2, 3]],
+          [[0], [1, 2, 3, 2, 1], [1]],
+          [[0], [2, 1, 3], [3, 2, 1]]]]
+
+    """
+    nstrands = braid.parent().strands()
+    l = braid.Tietze()
+    sig_on()
+    cdef list[list[list[list[int]]]] rop = CyclicSlidings(nstrands, l)
+    sig_off()
+    return rop