snappy 3.3__cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

snappy/drilling/crush.py

@@ -0,0 +1,270 @@
+from .cusps import CuspPostDrillInfo
+from .peripheral_curves import install_peripheral_curves
+from .barycentric import transpositions, perm_to_index
+
+from ..snap.t3mlite import Tetrahedron, Perm4, Mcomplex, simplex
+
+from typing import Set, Sequence
+
+def crush_geodesic_pieces(tetrahedra : Sequence[Tetrahedron]) -> Mcomplex:
+    """
+    Given tetrahedra produced by traverse_geodesics_to_subdivide,
+    compute the barycentric subdivision and crush all subtetrahedra in the
+    barycentric subdivision that have been marked as being adjacent to an edge
+    that coincides with a GeodesicPiece.
+
+    The function mark_subtetrahedra_about_geodesic_pieces marks the
+    subtetrahedra as described above.
+    """
+
+    # We call the tetrahedra in the barycentric subdivision subtetrahedra
+    # to distinguish them from the original tetrahedra.
+
+    # We order the vertices of a subtetrahedra such that 0 corresponds to an
+    # original vertex, vertex 1 to an edge center, ... of a tetrahedron.
+    # This means that half of the subtetrahedra have the orientation
+    # reversed from the tetrahedron.
+
+    # While it is conceptually easier to think of creating the barycentric
+    # subdivision and then doing the crushing in two steps, we actually do
+    # not create a separate Mcomplex for the intermediate barycentric
+    # subdivison.
+
+    # Recall that each subtetrahedron in the barycentric subdivision
+    # is given by a pair of a tetrahedron tet and a permutation p.
+    # Using the index i that p has in Perm4.S4, we index
+    # a subtetrahedron by 24 * tet.Index + i.
+
+    # The subtetrahedra that are supposed to be curshed in the barycentric
+    # are assumed to be marked in tet.marked_subtetrahedra.
+    #
+    # Later, we also pick a subtetrahedron for each simple closed curve to
+    # compute a new meridian and longitude.
+
+    # Use bit mask to create the subtetrahedra surviving the crushing.
+    subtetrahedra = [
+        Tetrahedron() if marked_subtet == 0 else None
+        for tet in tetrahedra
+        for marked_subtet in tet.marked_subtetrahedra ]
+
+    _assign_orientations(subtetrahedra)
+
+    # Now glue the subtetrahedra in the crushed complex.
+    # Also carry forward post drill infos and peripheral curves.
+    for tet in tetrahedra:
+        for i, perm in enumerate(Perm4.S4()):
+            subtet_index = 24 * tet.Index + i
+            subtet = subtetrahedra[subtet_index]
+
+            if subtet is None:
+                continue
+
+            # The gluings internal (between subtetrahedra of the
+            # same tetrahedron)
+            for face in range(3):
+                other_perm = perm * transpositions[face]
+                j = perm_to_index(other_perm)
+                other_subtet_index = 24 * tet.Index + j
+                if face == 1 and tet.marked_subtetrahedra[j] != 0:
+                    # We are processing subtetrahedron t and its
+                    # neighbor c is adjacent to a GeodesicPiece (=)
+                    # and thus it and its neighbor c' get crushed.
+                    # Thus, we need to glue t to t'.
+                    #
+                    #              0
+                    #             /|\
+                    #            / | \
+                    #           /  |  \
+                    #          /   |   \
+                    #         1*   |   *1
+                    #        /   * | *   \
+                    #       / t    2   t' \
+                    #      /     * | *     \
+                    #     /    *   |   *    \
+                    #    /   *     |     *   \
+                    #   /  *   c   |  c'   *  \
+                    #  / *         |         * \
+                    # 0============1============0
+                    #
+                    other_perm = perm * Perm4((2,1,0,3))
+                    j = perm_to_index(other_perm)
+                    other_subtet_index = 24 * tet.Index + j
+                # attach is working symmetrically also setting the Neighbors
+                # and Gluings of the other tetrahedron, so only call it once
+                # per face-pairing
+                if j > i:
+                    subtet.attach(simplex.TwoSubsimplices[face],
+                                  subtetrahedra[other_subtet_index],
+                                  (0,1,2,3))
+
+            # The external gluing.
+            vertex = perm.image(simplex.V0)
+            face = perm.image(simplex.F3)
+            other_tet = tet.Neighbor[face]
+            other_perm = tet.Gluing[face] * perm
+            j = perm_to_index(other_perm)
+            other_subtet_index = 24 * other_tet.Index + j
+            if other_subtet_index > subtet_index:
+                subtet.attach(simplex.F3,
+                              subtetrahedra[other_subtet_index],
+                              (0,1,2,3))
+
+            # Only vertex 0 corresponds to an original vertex.
+            # The other vertices will actually be finite, i.e., have
+            # spherical vertex links.
+            subtet.post_drill_infos = {
+                simplex.V0 : tet.post_drill_infos[vertex],
+                simplex.V1 : CuspPostDrillInfo(),
+                simplex.V2 : CuspPostDrillInfo(),
+                simplex.V3 : CuspPostDrillInfo() }
+
+            # Transfer peripheral curves. Note that for the same reason
+            # this is only relevant for vertex 0.
+            #
+            # Recall that SnapPea stores the peripheral curves on the
+            # half-edges of the dual 1-skeleton of the cusp triangulation.
+            #
+            # tet.PeripheralCurves is a structure similar to the one in the
+            # SnapPea kernel (see peripheral_curves.c for more info) nested
+            # as follows:
+            # - list for meridian and longitude
+            # - list for sheets in orientation double-cover of cusp triangle
+            # - dict with key being the vertex where the cusp triangle is
+            # - dict with key being a face of tetrahedron. The face intersects
+            #   the cusp triangle in an edge. The value says how often the
+            #   dual half-edge participates in the peripheral curve.
+            #
+            # After the barycentric subdivision, the original cusp triangle
+            # is split as shown:
+            #
+            #              1
+            #             /|\
+            #            / | \
+            #           /  |  \
+            #          /   |   \       The six new cusp triangles
+            #         2*   |   *2
+            #        /   * | *   \
+            #       /      3      \
+            #      /     * | *     \
+            #     /    *   |   *    \
+            #    /   *     |     *   \
+            #   /  *       |       *  \
+            #  / *         |         * \
+            # 1------------2------------1
+            #
+            # We first transfer the original peripheral curves to the dual
+            # half-edges opposite vertex 3 in the above picture.
+            # The resulting chain will thus temporarily fail to be a cycle.
+            # Later, we fix the chains to be cycles again by adding values
+            # to the half-edges forming a circle about vertex 3 in the
+            # above picture - in _fix_all_peripheral_curves.
+
+            subtet.needs_peripheral_curves_fixed = False
+            subtet.PeripheralCurves = [
+                [ { v : { f : 0 for f in simplex.TwoSubsimplices }
+                    for v in simplex.ZeroSubsimplices }
+                  for sheet in range(2) ]
+                for ml in range(2) ]
+            for ml in range(2): # For meridian and longitude
+                for sheet in range(2): # For two-sheets in orientation-double cover
+                    p = tet.PeripheralCurves[ml][sheet][vertex][face]
+                    # Note that in the above picture, an edge of the original
+                    # cusp triangle is split into two. Thus, we have two triangles
+                    # to pick from when transferring the value of an old dualf
+                    # half-edge to the new cusp triangles.
+                    #
+                    # We do these choices so that the cycle condition is at least
+                    # fulfilled for the edges coinciding with the edges of the
+                    # original cusp triangle.
+                    if p > 0 and perm.sign() == 0:
+                        subtet.PeripheralCurves[ml][sheet][simplex.V0][simplex.F3] = p
+                        subtet.needs_peripheral_curves_fixed = True
+                    elif p < 0 and perm.sign() == 1:
+                        subtet.PeripheralCurves[ml][1 - sheet][simplex.V0][simplex.F3] = p
+
+    _fix_all_peripheral_curves(subtetrahedra)
+
+    # Find peripheral curves for each cusps created by crushing the simple
+    # closed curves.
+    # Record which of these cusps was already processed to only do this once
+    # per cusp.
+    new_cusp_indices : Set[int] = set()    
+    for tet in tetrahedra:
+        for perm, orientation in zip(Perm4.S4(), tet.marked_subtetrahedra):
+            # We found a subtetrahedron adjacent to a geodesic piece.
+            #
+            # Make sure its 0-1 edge is parallel and not anti-parallel to
+            # the geodesic piece. This way the longitude will be parallel to
+            # the geodesic piece.
+            if orientation != +1:
+                continue
+            # Check orientation of subtetrahedron so that the orientation of
+            # the meridian relative to the longitude matches the orientation of the
+            # cusp.
+            if perm.sign() == 1:
+                continue
+            v : int = perm.image(simplex.V0)
+            cusp_index : int = tet.post_drill_infos[v].index
+            if cusp_index is None:
+                raise Exception("Vertex on geodesic has no assigned cusp")
+            if cusp_index in new_cusp_indices:
+                continue
+            # First time we encounter this simple closed curve. Pick a base
+            # tet to install the meridian and longitude.
+            # This base tet better not be one of the subtetrahedra that is
+            # crushed. So pick a neighbor of the subtetrahedron adjacent
+            # to the geodesic piece.
+            other_perm = perm * transpositions[1]
+            subtet_index = 24 * tet.Index + perm_to_index(other_perm)
+            install_peripheral_curves(subtetrahedra[subtet_index])
+            new_cusp_indices.add(cusp_index)
+    
+    # To preserve the orientation, make sure that the first subtetrahedron
+    # we pass to Mcomplex has the same orientation as the original tetrahedron
+    # - since the SnapPea kernel will use the first tetrahedron of an
+    # orientable triangulation to orient it.
+    return Mcomplex([ subtet
+                      for s in [0, 1]
+                      for subtet in subtetrahedra
+                      if subtet and subtet.orientation == s ])
+
+def _assign_orientations(subtetrahedra):
+    for j in range(len(subtetrahedra) // 24):
+        for i, perm in enumerate(Perm4.S4()):
+            subtet_index = 24 * j + i
+            subtet = subtetrahedra[subtet_index]
+            if subtet:
+                subtet.orientation = perm.sign()
+
+
+def _fix_peripheral_curves(subtet):
+    """
+    Traverse the six new cusp triangles shown in one
+    of the figures in crush_geodesic_pieces.
+    """
+    for i in range(6):
+        subtet.needs_peripheral_curves_fixed = False
+
+        if i % 2 == 0:
+            face0, face1 = simplex.F1, simplex.F2
+        else:
+            face0, face1 = simplex.F2, simplex.F1
+        neighbor = subtet.Neighbor[face1]
+        for ml in range(2):
+            for sheet in range(2):
+                tri = subtet.PeripheralCurves[ml][sheet][simplex.V0]
+                p = tri[face0] + tri[simplex.F3]
+                tri[face1] = -p
+                neighbor.PeripheralCurves[ml][1-sheet][simplex.V0][face1] = p
+        subtet = neighbor
+
+
+def _fix_all_peripheral_curves(subtetrahedra):
+    """
+    Fix peripheral curves for all subtetrahedra that require it, see
+    crush_geodesic_pieces where the needs_peripheral_curves_fixed flag
+    was raised for details.
+    """
+    for subtet in subtetrahedra:
+        if subtet and subtet.needs_peripheral_curves_fixed:
+            _fix_peripheral_curves(subtet)

snappy/drilling/cusps.py

@@ -0,0 +1,125 @@
+from ..geometric_structure.geodesic.geodesic_start_point_info import GeodesicStartPointInfo
+from ..geometric_structure import Filling, FillingMatrix
+
+from ..snap.t3mlite import Mcomplex, simplex
+
+from . import exceptions
+
+from typing import Tuple, Optional, Sequence
+
+# @dataclass
+
+
+class CuspPostDrillInfo:
+    """
+    Information carried around to be applied after drilling
+    the manifold when re-indexing the cusps, re-applying the
+    Dehn-fillings or changing the peripheral curve when drilling
+    a core curve.
+
+    Note that we store this information sometime on a
+    snappy.snap.t3mlite.Vertex as post_drill_info and sometimes
+    as a dictionary tet.post_drill_infos on each tetrahedron assigning
+    a CuspPostDrillInfo to each vertex of the tetrahedron. The latter
+    representation is more redundant as we need to store the same
+    CuspPostDrillInfo to each vertex of each tetrahedron belonging to
+    the same vertex class - but is also more convenient in certain
+    circumstances.
+    """
+
+    def __init__(self,
+                 # Index this vertex will have in the drilled manifold.
+                 # None if vertex is a finite vertex.
+                 index : Optional[int] = None,
+                 # Filling that needs to be applied after drilling the
+                 # manifold. (0,0) if cusps will be left unfilled.
+                 filling : Filling = (0, 0),
+                 # Optional adjustment of peripheral curves performed
+                 # to drilled manifold with Manifold.set_peripheral_curves.
+                 peripheral_matrix : Optional[FillingMatrix] = None):
+        self.index = index
+        self.filling = filling
+        self.peripheral_matrix = peripheral_matrix
+
+    def __eq__(self, other):
+        """
+        Used for debugging.
+        """
+        return (self.index == self.index and
+                self.filling == self.filling and
+                self.peripheral_matrix == self.peripheral_matrix)
+
+
+def index_geodesics_and_add_post_drill_infos(
+        geodesics : Sequence[GeodesicStartPointInfo],
+        mcomplex : Mcomplex) -> None:
+
+    all_reindexed_verts = {
+        g.core_curve_cusp for g in geodesics if g.core_curve_cusp}
+
+    old_vertices = [v for v in mcomplex.Vertices
+                    if v not in all_reindexed_verts]
+
+    for i, v in enumerate(old_vertices):
+        v.post_drill_info = CuspPostDrillInfo(
+            index=i, filling=v.filling_matrix[0])
+
+    n = len(old_vertices)
+
+    for i, g in enumerate(geodesics):
+        if g.core_curve_cusp:
+            if g.core_curve_multiplicity not in [-1, +1]:
+                raise exceptions.GeodesicMultipleOfCoreCurve(
+                    g.word, g.core_curve_multiplicity)
+
+            g.core_curve_cusp.post_drill_info = CuspPostDrillInfo(
+                index=n + i,
+                peripheral_matrix=_multiply_filling_matrix(
+                    g.core_curve_cusp.filling_matrix,
+                    g.core_curve_multiplicity))
+        else:
+            g.index = n + i
+
+    for tet in mcomplex.Tetrahedra:
+        tet.post_drill_infos = {
+            V : tet.Class[V].post_drill_info
+            for V in simplex.ZeroSubsimplices }
+
+
+def reorder_vertices_and_get_post_drill_infos(
+        mcomplex : Mcomplex) -> Sequence[CuspPostDrillInfo]:
+
+    cusp_vertices_dict = { }
+    finite_vertices = [ ]
+    for vert in mcomplex.Vertices:
+        c = vert.Corners[0]
+        post_drill_info = c.Tetrahedron.post_drill_infos[c.Subsimplex]
+        vert.post_drill_info = post_drill_info
+        if post_drill_info.index is None:
+            finite_vertices.append(vert)
+        else:
+            cusp_vertices_dict[post_drill_info.index] = vert
+
+    cusp_vertices = [ cusp_vertices_dict[i]
+                      for i in range(len(cusp_vertices_dict)) ]
+
+    mcomplex.Vertices = cusp_vertices + finite_vertices
+
+    return [ v.post_drill_info for v in cusp_vertices ]
+
+
+def refill_and_adjust_peripheral_curves(
+        manifold,
+        post_drill_infos : Sequence[CuspPostDrillInfo]) -> None:
+
+    manifold.dehn_fill([ info.filling for info in post_drill_infos])
+
+    for info in post_drill_infos:
+        if info.peripheral_matrix is not None:
+            manifold.set_peripheral_curves(
+                info.peripheral_matrix, which_cusp=info.index)
+
+
+def _multiply_filling_matrix(m : FillingMatrix, s : int) -> FillingMatrix:
+    return ((s * m[0][0], s * m[0][1]),
+            (s * m[1][0], s * m[1][1]))

snappy/drilling/debug.py

@@ -0,0 +1,242 @@
+from ..snap.t3mlite import simplex
+from ..matrix import make_identity_matrix
+from ..hyperboloid import *
+
+
+def _find_all_tetrahedra(tet):
+    result = [ ]
+    pending_tets = [ tet ]
+    visited_tets = set()
+    while pending_tets:
+        tet = pending_tets.pop()
+        if tet not in visited_tets:
+            visited_tets.add(tet)
+            result.append(tet)
+            for neighbor in tet.Neighbor.values():
+                pending_tets.append(neighbor)
+    return result
+
+
+def check_peripheral_curves(tets):
+    for tet in tets:
+        for f in simplex.TwoSubsimplices:
+            neighbor = tet.Neighbor[f]
+            gluing = tet.Gluing[f]
+            other_f = gluing.image(f)
+            sgn = gluing.sign()
+            for v in simplex.ZeroSubsimplices:
+                v_comp = simplex.comp(v)
+                other_v = gluing.image(v)
+                for ml in range(2):
+                    for sheet_index in range(2):
+                        sheet = tet.PeripheralCurves[ml][sheet_index][v]
+                        if f == v_comp:
+                            if sum(sheet.values()) != 0:
+                                raise Exception("Not adding up to zero. %r" % tet)
+                            if sheet[v_comp] != 0:
+                                raise Exception("Diagonal entry for peripheral curve.")
+                        else:
+                            if sgn == 0:
+                                other_sheet_index = 1 - sheet_index
+                            else:
+                                other_sheet_index = sheet_index
+                            a = sheet[f]
+                            b = neighbor.PeripheralCurves[ml][other_sheet_index][other_v][other_f]
+                            if a + b != 0:
+                                raise Exception("Peripheral curve not adding up.")
+
+
+def check_vertex_indices(tets):
+    for tet in tets:
+        for v in simplex.ZeroSubsimplices:
+            index = tet.post_drill_infos[v]
+            for f in simplex.TwoSubsimplices:
+                if v & f:
+                    if tet.Neighbor[f].post_drill_infos[tet.Gluing[f].image(v)] != index:
+                        print("tet, v face:", tet, v, f)
+                        print("index and other index:", index, tet.Neighbor[f].post_drill_infos, [tet.Gluing[f].image(v)])
+                        raise Exception("Neighbors don't have same vertex.")
+
+
+def check_points_equal(v0, v1):
+    RF = v0[0].parent()
+
+    if abs(r13_dot(v0, v0)) < RF(1e-10):
+        if abs(r13_dot(v1, v1)) > RF(1e-10):
+            raise Exception("Light-like vs time-like:", v0, v1)
+        if abs(r13_dot(v0, v1)) > RF(1e-10):
+            raise Exception("Non-colinlinear light like:", v0, v1)
+    else:
+        if any(abs(x - y) > RF(1e-10) for x, y in zip(v0, v1)):
+            raise Exception("Different time-like:", v0, v1)
+
+
+def check_points_consistency(m):
+    for tet in m.Tetrahedra:
+        for F in simplex.TwoSubsimplices:
+            for V in simplex.ZeroSubsimplices:
+                if V & F:
+                    check_points_equal(
+                        tet.O13_matrices[F] * tet.R13_vertices[V],
+                        tet.Neighbor[F].R13_vertices[tet.Gluing[F].image(V)])
+
+
+def check_edge_consistency(m):
+    RF = m.Tetrahedra[0].O13_matrices[simplex.F0].base_ring()
+    id_matrix = make_identity_matrix(ring=RF, n=4)
+
+    for e in m.Edges:
+        t = id_matrix
+        for tet, perm in e.embeddings():
+            t = tet.O13_matrices[perm.image(simplex.F2)] * t
+        t = t - id_matrix
+        for i in range(4):
+            for j in range(4):
+                if abs(t[i,j]) > RF(1e-10):
+                    raise Exception("Edge not gluing up")
+
+
+def check_geodesic1(tets):
+    RF = tets[0].O13_matrices[simplex.F0].base_ring()
+
+    for tet in tets:
+        for geodesic_segment in tet.geodesic_pieces:
+            if geodesic_segment.tet is not tet:
+                raise Exception("Geodesic tet inconsistency")
+
+            for ptInClass in geodesic_segment.endpoints:
+                if ptInClass.subsimplex in simplex.ZeroSubsimplices:
+                    check_points_equal(
+                        ptInClass.r13_point,
+                        tet.R13_vertices[ptInClass.subsimplex])
+                else:
+                    if abs(r13_dot(ptInClass.r13_point, tet.R13_planes[ptInClass.subsimplex])) > RF(1e-10):
+                        raise Exception("Point not on plane")
+
+
+def check_consistency(mcomplex):
+    check_edge_consistency(mcomplex)
+    check_points_consistency(mcomplex)
+    check_geodesic1(mcomplex.Tetrahedra)
+
+
+def check_consistency_segments(segments):
+    for i in range(len(segments)):
+        s0 = segments[i]
+        s1 = segments[(i+1) % len(segments)]
+
+        if s0.tet.Class[s0.endpoints[1].subsimplex] is not s1.tet.Class[s1.endpoints[0].subsimplex]:
+            raise Exception("Classes of consecutive segments not matching %i" % i)
+
+        if s0.next_ is not s1:
+            raise Exception("Linked list broken (next)")
+        if s1.prev is not s0:
+            raise Exception("Linked list broken (prev)")
+
+        if s0.endpoints[1].subsimplex in simplex.TwoSubsimplices:
+            check_points_equal(
+                s0.tet.O13_matrices[s0.endpoints[1].subsimplex] * s0.endpoints[1].r13_point,
+                s1.endpoints[0].r13_point)
+
+
+def print_cell(f):
+    if f in simplex.ZeroSubsimplices:
+        return "V"
+    if f in simplex.TwoSubsimplices:
+        return "F"
+    if f == simplex.T:
+        return "T"
+    raise Exception("BLAH")
+
+
+def output_linked(x, tets_set):
+    y = x
+    while True:
+        # print(y)
+        print(print_cell(y.endpoints[0].subsimplex) + "-----" + print_cell(y.endpoints[1].subsimplex), end=" ")
+        y = y.next_
+        if x is y:
+            break
+
+    print()
+
+    y = x
+    while True:
+        print("%2d---%2d" % (y.endpoints[0].subsimplex, y.endpoints[1].subsimplex), end=" ")
+        y = y.next_
+        if x is y:
+            break
+
+    print()
+
+    y = x
+    while True:
+        if y.tet in tets_set:
+            print("   *   ", end=" ")
+        else:
+            print("       ", end=" ")
+        y = y.next_
+        if x is y:
+            break
+
+    print()
+    print()
+
+
+def flatten_link_list(x):
+    y = x
+    l = []
+    while True:
+        l.append(y)
+        y = y.next_
+        if x is y:
+            return l
+
+
+def check_consistency_2(piece):
+    tets = _find_all_tetrahedra(piece.tet)
+
+    tets_set = set(tets)
+
+    to_pieces_map = {  }
+
+    num_pieces = 0
+
+    for tet in tets:
+        for piece in tet.geodesic_pieces:
+
+            num_pieces += 1
+
+            if piece.tet is not tet:
+                raise Exception("Piece.tet not pointing to tet.")
+            if piece.next_.prev is not piece:
+                raise Exception("Link list broken.")
+            if piece.prev.next_ is not piece:
+                raise Exception("Link list broken.")
+
+            if piece.index != piece.next_.index:
+                raise Exception("Index inconsistent.")
+
+            if piece.index != piece.prev.index:
+                raise Exception("Index inconsistent.")
+
+            if piece.index not in to_pieces_map:
+                l = flatten_link_list(piece)
+                for i, p in enumerate(l):
+                    if p is piece:
+                        l == l[i:] + l[:i]
+                        break
+                else:
+                    for i, p in enumerate(l):
+                        if p.endpoints[0].subsimplex == simplex.T:
+                            l == l[i:] + l[:i]
+                            break
+
+                to_pieces_map[piece.index] = l
+
+    if False:
+        for i, pieces in sorted(to_pieces_map.items()):
+            print("Component %d (length %d):" % (i, len(pieces)))
+            output_linked(pieces[0], tets_set)
+
+        print("Total length: %d" % num_pieces)

snappy/drilling/epsilons.py

@@ -0,0 +1,6 @@
+def compute_epsilon(RF):
+    return RF(0.5) ** (RF.prec() // 2)
+
+
+def compute_tube_injectivity_radius_epsilon(RF):
+    return RF(0.5) ** (RF.prec() // 2 - 8)

snappy/drilling/exceptions.py

@@ -0,0 +1,55 @@
+class DrillGeodesicError(RuntimeError):
+    pass
+
+class GeodesicSystemNotSimpleError(DrillGeodesicError):
+    def __init__(self, maximal_tube_radius):
+        self.maximal_tube_radius = maximal_tube_radius
+        super().__init__(
+            "One of the given geodesics might not simple or two of the "
+            "given geodesics might intersect. "
+            "The maximal tube radius about the given system of geodesics "
+            "was estimated to be: %r." % maximal_tube_radius)
+
+class GeodesicMultipleOfCoreCurve(DrillGeodesicError):
+    def __init__(self, word, multiplicity):
+        self.word = word
+        self.multiplicity = multiplicity
+        super().__init__(
+            "The geodesic %s is a %d-fold multiple of a core curve." % (
+                word, multiplicity))
+
+class UnfinishedTraceGeodesicError(DrillGeodesicError):
+    def __init__(self, steps):
+        self.steps = steps
+        super().__init__(
+            "The geodesic seems to have more than %d pieces in the "
+            "triangulation. This is probably due to a pathology, "
+            "e.g., the geodesic is very close to a core curve of "
+            "filled cusp." % steps)
+
+class GeodesicHittingOneSkeletonError(DrillGeodesicError):
+    """
+    Base class for exceptions caused by the geodesic hitting the
+    1-skeleton and that can be avoided by perturbing the geodesic.
+    """
+
+
+class GeodesicStartPointOnTwoSkeletonError(GeodesicHittingOneSkeletonError):
+    """
+    Raised when the start point given to GeodesicStartPointInfo appears not to be in the
+    interior of a tetrahedron.
+    """
+
+
+class RayHittingOneSkeletonError(GeodesicHittingOneSkeletonError):
+    """
+    Raised when the geodesic appears to intersect the 1-skeleton of the
+    original triangulation.
+    """
+
+
+class RetracingRayHittingOneSkeletonError(GeodesicHittingOneSkeletonError):
+    """
+    Raised when the geodesic appears to intersect the 1-skeleton of the
+    subdivided triangulation.
+    """