snappy 3.1.1__cp311-cp311-macosx_11_0_arm64.whl → 3.2__cp311-cp311-macosx_11_0_arm64.whl

snappy/geometric_structure/cusp_neighborhood/real_cusp_cross_section.py

@@ -0,0 +1,298 @@
+from .cusp_cross_section_base import CuspCrossSectionBase, HoroTriangleBase
+from .exceptions import IncompleteCuspError, ConsistencyWithSnapPeaNumericalVerifyError
+
+from ...snap.kernel_structures import TransferKernelStructuresEngine
+from ...snap import t3mlite as t3m
+from ...snap.t3mlite import simplex
+
+class RealHoroTriangle:
+    """
+    A horosphere cross section in the corner of an ideal tetrahedron.
+    The sides of the triangle correspond to faces of the tetrahedron.
+    The lengths stored for the triangle are real.
+    """
+    def __init__(self, tet, vertex, known_side, length_of_side=None):
+        left_side, center_side, right_side, z_left, z_right = (
+            HoroTriangleBase._sides_and_cross_ratios(tet, vertex, known_side))
+
+        if length_of_side is None:
+            RF = z_left.real().parent()
+            L = RF(1)
+        else:
+            L = length_of_side
+
+        self.lengths = { center_side : L,
+                         left_side   : abs(z_left) * L,
+                         right_side  : L / abs(z_right) }
+        a, b, c = self.lengths.values()
+        self.area = L * L * z_left.imag() / 2
+
+        # Below is the usual formula for circumradius
+        self.circumradius = a * b * c / (4 * self.area)
+
+    def rescale(self, t):
+        "Rescales the triangle by a Euclidean dilation"
+        for face in self.lengths:
+            self.lengths[face] *= t
+        self.circumradius *= t
+        self.area *= t * t
+
+    def get_real_lengths(self):
+        return self.lengths
+
+    @staticmethod
+    def direction_sign():
+        return +1
+
+class RealCuspCrossSection(CuspCrossSectionBase):
+    """
+    A t3m triangulation with real edge lengths of cusp cross sections built
+    from a cusped (possibly non-orientable) SnapPy manifold M with a hyperbolic
+    structure specified by shapes. It can scale the cusps to areas that can be
+    specified or scale them such that they are disjoint.
+    It can also compute the "tilts" used in the Tilt Theorem, see
+    ``canonize_part_1.c``.
+
+    The computations are agnostic about the type of numbers provided as shapes
+    as long as they provide ``+``, ``-``, ``*``, ``/``, ``conjugate()``,
+    ``im()``, ``abs()``, ``sqrt()``.
+    Shapes can be a numerical type such as ComplexIntervalField or an exact
+    type (supporting sqrt) such as QQbar.
+
+    The resulting edge lengths and tilts will be of the type returned by
+    applying the above operations to the shapes. For example, if the shapes
+    are in ComplexIntervalField, the edge lengths and tilts are elements in
+    RealIntervalField.
+
+    **Remark:** The real edge lengths could also be obtained from the complex
+    edge lengths computed by ``ComplexCuspCrossSection``, but this has two
+    drawbacks. The times at which we apply ``abs`` or ``sqrt`` during the
+    development and rescaling of the cusps would be different. Though this
+    gives the same values, the resulting representation of these values by an
+    exact number type (such as the ones in ``squareExtension.py``) might be
+    prohibitively more complicated. Furthermore, ``ComplexCuspCrossSection``
+    does not work for non-orientable manifolds (it does not implement working
+    in a cusp's double-cover like the SnapPea kernel does).
+
+    Original source:
+    Asymmetric hyperbolic L-spaces, Heegaard genus, and Dehn filling
+    Nathan M. Dunfield, Neil R. Hoffman, Joan E. Licata
+    http://arxiv.org/abs/1407.7827
+    """
+
+    HoroTriangle = RealHoroTriangle
+
+    @staticmethod
+    def fromManifoldAndShapes(manifold, shapes):
+        """
+        **Examples:**
+
+        Initialize from shapes provided from the floats returned by
+        tetrahedra_shapes. The tilts appear to be negative but are not
+        verified by interval arithmetics::
+
+          >>> from snappy import Manifold
+          >>> M = Manifold("m004")
+          >>> M.canonize()
+          >>> shapes = M.tetrahedra_shapes('rect')
+          >>> e = RealCuspCrossSection.fromManifoldAndShapes(M, shapes)
+          >>> e.normalize_cusps()
+          >>> e.compute_tilts()
+          >>> tilts = e.read_tilts()
+          >>> for tilt in tilts:
+          ...     print('%.8f' % tilt)
+          -0.31020162
+          -0.31020162
+          -0.31020162
+          -0.31020162
+          -0.31020162
+          -0.31020162
+          -0.31020162
+          -0.31020162
+
+        Use verified intervals:
+
+        sage: from snappy.verify import *
+        sage: M = Manifold("m004")
+        sage: M.canonize()
+        sage: shapes = M.tetrahedra_shapes('rect', intervals=True)
+
+        Verify that the tetrahedra shapes form a complete manifold:
+
+        sage: check_logarithmic_gluing_equations_and_positively_oriented_tets(M,shapes)
+        sage: e = RealCuspCrossSection.fromManifoldAndShapes(M, shapes)
+        sage: e.normalize_cusps()
+        sage: e.compute_tilts()
+
+
+        Tilts are verified to be negative:
+
+        sage: [tilt < 0 for tilt in e.read_tilts()]
+        [True, True, True, True, True, True, True, True]
+
+        Setup necessary things in Sage:
+
+        sage: from sage.rings.qqbar import QQbar
+        sage: from sage.rings.rational_field import RationalField
+        sage: from sage.rings.polynomial.polynomial_ring import polygen
+        sage: from sage.rings.real_mpfi import RealIntervalField
+        sage: from sage.rings.complex_interval_field import ComplexIntervalField
+        sage: x = polygen(RationalField())
+        sage: RIF = RealIntervalField()
+        sage: CIF = ComplexIntervalField()
+
+        sage: M = Manifold("m412")
+        sage: M.canonize()
+
+        Make our own exact shapes using Sage. They are the root of the given
+        polynomial isolated by the given interval.
+
+        sage: r=QQbar.polynomial_root(x**2-x+1,CIF(RIF(0.49,0.51),RIF(0.86,0.87)))
+        sage: shapes = 5 * [r]
+        sage: e=RealCuspCrossSection.fromManifoldAndShapes(M, shapes)
+        sage: e.normalize_cusps()
+
+        The following three lines verify that we have shapes giving a complete
+        hyperbolic structure. The last one uses complex interval arithmetics.
+
+        sage: from snappy.verify import edge_equations
+        sage: edge_equations.check_polynomial_edge_equations_exactly(e.mcomplex)
+        sage: e.check_cusp_development_exactly()
+        sage: edge_equations.check_logarithmic_edge_equations_and_positivity(e.mcomplex, CIF)
+
+        Because we use exact types, we can verify that each tilt is either
+        negative or exactly zero.
+
+        sage: e.compute_tilts()
+        sage: [(tilt < 0, tilt == 0) for tilt in e.read_tilts()]
+        [(True, False), (True, False), (False, True), (True, False), (True, False), (True, False), (True, False), (False, True), (True, False), (True, False), (True, False), (False, True), (False, True), (False, True), (False, True), (False, True), (True, False), (True, False), (False, True), (True, False)]
+
+        Some are exactly zero, so the canonical cell decomposition has
+        non-tetrahedral cells. In fact, the one cell is a cube. We can obtain
+        the retriangulation of the canonical cell decomposition as follows:
+
+        sage: e.compute_tilts()
+        sage: opacities = [tilt < 0 for tilt in e.read_tilts()]
+        sage: N = M._canonical_retriangulation()
+        sage: N.num_tetrahedra()
+        12
+
+        The manifold m412 has 8 isometries, the above code certified that using
+        exact arithmetic:
+        sage: len(N.isomorphisms_to(N))
+        8
+        """
+        for cusp_info in manifold.cusp_info():
+            if not cusp_info['complete?']:
+                raise IncompleteCuspError(manifold)
+
+        m = t3m.Mcomplex(manifold)
+
+        t = TransferKernelStructuresEngine(m, manifold)
+        t.reindex_cusps_and_transfer_peripheral_curves()
+        t.add_shapes(shapes)
+
+        c = RealCuspCrossSection(m)
+        c.add_structures()
+
+        # For testing against SnapPea kernel data
+        c.manifold = manifold
+
+        return c
+
+    @staticmethod
+    def _tet_tilt(tet : t3m.Tetrahedron, face : int):
+        "The tilt of the face of the tetrahedron."
+
+        v = simplex.comp(face)
+
+        ans = 0
+        for w in simplex.ZeroSubsimplices:
+            if v == w:
+                c_w = 1
+            else:
+                z = tet.ShapeParameters[v | w]
+                c_w = -z.real() / abs(z)
+            R_w = tet.horotriangles[w].circumradius
+            ans += c_w * R_w
+        return ans
+
+    @staticmethod
+    def _face_tilt(face : t3m.Face):
+        """
+        Tilt of a face in the triangulation: this is the sum of
+        the two tilts of the two faces of the two tetrahedra that are
+        glued. The argument is a simplex.Face.
+        """
+
+        return sum([ RealCuspCrossSection._tet_tilt(corner.Tetrahedron,
+                                                    corner.Subsimplex)
+                     for corner in face.Corners ])
+
+    def compute_tilts(self):
+        """
+        Computes all tilts. They are written to the instances of
+        simplex.Face and can be accessed as
+        [ face.Tilt for face in crossSection.Faces].
+        """
+
+        for face in self.mcomplex.Faces:
+            face.Tilt = RealCuspCrossSection._face_tilt(face)
+
+    def read_tilts(self):
+        """
+        After compute_tilts() has been called, put the tilt values into an
+        array containing the tilt of face 0, 1, 2, 3 of the first tetrahedron,
+        ... of the second tetrahedron, ....
+        """
+
+        def index_of_face_corner(corner):
+            face_index = simplex.comp(corner.Subsimplex).bit_length() - 1
+            return 4 * corner.Tetrahedron.Index + face_index
+
+        tilts = (4 * len(self.mcomplex.Tetrahedra)) * [ None ]
+
+        # For each face of the triangulation
+        for face in self.mcomplex.Faces:
+            for corner in face.Corners:
+                tilts[index_of_face_corner(corner)] = face.Tilt
+
+        return tilts
+
+    def _testing_check_against_snappea(self, epsilon):
+        """
+        Compare the computed edge lengths and tilts against the one computed by
+        the SnapPea kernel.
+
+        >>> from snappy import Manifold
+
+        Convention of the kernel is to use (3/8) sqrt(3) as area (ensuring that
+        cusp neighborhoods are disjoint).
+
+        >>> cusp_area = 0.649519052838329
+
+        >>> for name in ['m009', 'm015', 't02333']:
+        ...     M = Manifold(name)
+        ...     e = RealCuspCrossSection.fromManifoldAndShapes(M, M.tetrahedra_shapes('rect'))
+        ...     e.normalize_cusps(cusp_area)
+        ...     e._testing_check_against_snappea(1e-10)
+
+        """
+
+        CuspCrossSectionBase._testing_check_against_snappea(self, epsilon)
+
+        # Short-hand
+        TwoSubs = simplex.TwoSubsimplices
+
+        # SnapPea kernel results
+        snappea_tilts, snappea_edges = self.manifold._cusp_cross_section_info()
+
+        # Check tilts
+        # Iterate through tet
+        for tet, snappea_tet_tilts in zip(self.mcomplex.Tetrahedra, snappea_tilts):
+            # Iterate through vertices of tet
+            for f, snappea_tet_tilt in zip(TwoSubs, snappea_tet_tilts):
+                tilt = RealCuspCrossSection._tet_tilt(tet, f)
+                if not abs(snappea_tet_tilt - tilt) < epsilon:
+                    raise ConsistencyWithSnapPeaNumericalVerifyError(
+                        snappea_tet_tilt, tilt)

snappy/geometric_structure/cusp_neighborhood/tiles_for_cusp_neighborhood.py

@@ -0,0 +1,159 @@
+from .exceptions import IncompleteCuspError
+from .real_cusp_cross_section import RealCuspCrossSection
+from .vertices import scale_vertices_from_horotriangles
+from .. import add_r13_geometry
+
+from ...hyperboloid.horoball import R13Horoball
+from ...tiling.tile import Tile, compute_tiles
+from ...tiling.triangle import add_triangles_to_tetrahedra
+from ...tiling.lifted_tetrahedron import LiftedTetrahedron
+from ...tiling.lifted_tetrahedron_set import (LiftedTetrahedronSet,
+                                              get_lifted_tetrahedron_set)
+from ...tiling.iter_utils import IteratorCache
+from ...snap.t3mlite import Mcomplex, Vertex, Corner
+from ...matrix import make_identity_matrix
+from ...math_basics import correct_min
+
+
+from typing import Sequence
+
+def mcomplex_for_tiling_cusp_neighborhoods(
+        manifold, bits_prec : int, verified : bool) -> Mcomplex:
+    """
+    Computes mcomplex such that each vertex has a function
+    tiles() returning a stream of tiles to cover the space
+    H^3 / peripheral group of corresponding cusp.
+    """
+    
+
+    for cusp_info in manifold.cusp_info():
+        if not cusp_info['complete?']:
+            raise IncompleteCuspError(manifold)
+
+    # Convert SnapPea kernel triangulation to python triangulation
+    # snappy.snap.t3mlite.Mcomplex
+    mcomplex = Mcomplex(manifold)
+
+    # Add vertices in hyperboloid model and other geometric information
+    add_r13_geometry(mcomplex,
+                     manifold,
+                     verified=verified, bits_prec=bits_prec)
+
+    add_triangles_to_tetrahedra(mcomplex)
+
+    add_cusp_cross_section(mcomplex)
+    scale_vertices_from_horotriangles(mcomplex)
+
+    for v in mcomplex.Vertices:
+        v._tiles = None
+        def tiles(v=v, verified=verified):
+            if v._tiles is None:
+                v._tiles = IteratorCache(
+                    compute_tiles_for_cusp_neighborhood(
+                        v, verified))
+            return v._tiles
+        v.tiles = tiles
+
+    return mcomplex
+
+def compute_tiles_for_cusp_neighborhood(
+        v : Vertex, verified : bool) -> Sequence[Tile]:
+    """
+    If suitable structures have been added to an Mcomplex
+    (add_r13_geometry, add_triangles_to_tetrahedra), returns
+    a stream of tiles to cover the space
+    H^3 / peripheral group of cusp corresponding to given
+    vertex.
+    """
+
+    corner = v.Corners[0]
+
+    horoball_defining_vec = corner.Tetrahedron.R13_vertices[corner.Subsimplex]
+    RF = horoball_defining_vec[0].parent()
+
+    # Lowest non-zero value expected is
+    # 2 * (v.lower_bound_embedding_scale ** 2)
+    #
+    # Divide by half so that we have some margin.
+
+    min_neg_prod_distinct = (v.lower_bound_embedding_scale ** 2)
+
+    if verified:
+        max_neg_prod_equal = min_neg_prod_distinct
+    else:
+        max_neg_prod_equal = _compute_prod_epsilon(RF)
+
+    initial_lifted_tetrahedron = LiftedTetrahedron(
+        corner.Tetrahedron, make_identity_matrix(ring=RF, n=4))
+
+    lifted_tetrahedron_set : LiftedTetrahedronSet = (
+        get_lifted_tetrahedron_set(
+            base_point=horoball_defining_vec,
+            act_on_base_point_by_inverse=True,
+            max_neg_prod_equal=max_neg_prod_equal,
+            min_neg_prod_distinct=min_neg_prod_distinct,
+            canonical_keys_function=None,
+            verified=verified))
+
+    return compute_tiles(
+        geometric_object=R13Horoball(horoball_defining_vec),
+        visited_lifted_tetrahedra=lifted_tetrahedron_set,
+        initial_lifted_tetrahedra=[ initial_lifted_tetrahedron ],
+        verified=verified)
+
+def add_cusp_cross_section(mcomplex : Mcomplex):
+    """
+    Adds cross section to all cusps. Recall that a cusp cross
+    section corresponds to a choice of horoballs about the vertices
+    corresponding to the cusp. Scales the defining light-like vectors
+    of the vertices of the tetrahedra such that they correspond to
+    these horoballs.
+    """
+
+    c = RealCuspCrossSection(mcomplex)
+    c.add_structures(None)
+
+    # Save cusp cross section for later
+    mcomplex.real_cusp_cross_section = c
+
+    for i, (v, area) in enumerate(
+            zip(mcomplex.Vertices, c.cusp_areas())):
+        # Area of cusp
+        v.cusp_area = area
+        # A cusp intersects the triangulation in standard form
+        # if for each tetrahedron, the corresponding horoball
+        # intersects the tetrahedron in three but not four faces.
+        #
+        # We store here how much the cusp can be scaled before it
+        # is no longer in standard form.
+        v.scale_for_std_form = (
+            c.compute_scale_for_std_form(v))
+        v.exp_self_distance_along_edges = (
+            c.exp_distance_neighborhoods_measured_along_edges(i, i))
+        # v.lower_bound_embedding_scale: lower bound on how much
+        # we can scale the cusp to stay embedded.
+        if v.exp_self_distance_along_edges is None:
+            v.lower_bound_embedding_scale = v.scale_for_std_form
+        else:
+            v.lower_bound_embedding_scale = correct_min(
+                [ v.scale_for_std_form,
+                  v.exp_self_distance_along_edges.sqrt() ])
+
+def _compute_prod_epsilon(RF):
+    p = RF.precision()
+
+    # We try to be a factor of at least several magnitudes smaller than
+    # 1/_compute_epsilon_inverse(RF) in hyperboloid_dict.py.
+    #
+    # This factor will even grow larger as the precision increases.
+    #
+    # That way, we will hopefully fail in _equality_predicate
+    # in hyperboloid_dict rather than failing by not hashing together
+    # lifted tetrahedra that should be the same but are not recognised
+    # as such because of numerical error.
+
+    result = RF(1e-8)
+    if p > 53:
+        result *= RF(0.5) ** ((p - 53) / 2)
+
+    return result

snappy/geometric_structure/cusp_neighborhood/vertices.py

@@ -0,0 +1,32 @@
+from ...hyperboloid import r13_dot
+from ...snap.t3mlite import simplex
+
+def scale_vertices_from_horotriangles(mcomplex):
+    """
+    Scales the R13 vertices of each tetrahedron so that
+    each defines a horosphere that intersects the tetrahedron
+    in a triangle congruent to the horo triangles coming
+    from a cusp cross section.
+    """
+    
+    for tet in mcomplex.Tetrahedra:
+        _scale_vertices_tet(tet)
+
+def _scale_vertices_tet(tet):
+    R13_vertex_products = {
+        v0 | v1 : r13_dot(pt0, pt1)
+        for v0, pt0 in tet.R13_vertices.items()
+        for v1, pt1 in tet.R13_vertices.items()
+        if v0 > v1 }
+
+    for v0 in simplex.ZeroSubsimplices:
+        v1, v2, _ = simplex.VerticesOfFaceCounterclockwise[simplex.comp(v0)]
+
+        length_on_cusp = tet.horotriangles[v0].get_real_lengths()[v0 | v1 | v2]
+        length_on_horosphere = (
+            -2 * R13_vertex_products[v1 | v2] / (
+                 R13_vertex_products[v0 | v1] *
+                 R13_vertex_products[v0 | v2])).sqrt()
+        s = length_on_horosphere / length_on_cusp
+
+        tet.R13_vertices[v0] = s * tet.R13_vertices[v0]

snappy/geometric_structure/geodesic/add_core_curves.py

@@ -0,0 +1,152 @@
+from .fixed_points import r13_fixed_line_of_psl2c_matrix
+from .line import R13LineWithMatrix
+from .. import word_list_to_psl2c_matrix
+from .. import Filling
+from ...upper_halfspace import sl2c_inverse # type: ignore
+from ...snap.t3mlite import Mcomplex, Vertex, Tetrahedron, simplex
+
+from collections import deque
+
+from typing import Tuple, Sequence, Optional
+
+def add_r13_core_curves(
+        mcomplex : Mcomplex,
+        manifold):
+
+    for tet in mcomplex.Tetrahedra:
+        # Dict, keys are a subset of simplex.ZeroSubsimplices
+        #
+        # If a vertex of a tet corresponds to a filled cusp, this dictionary
+        # will contain the appropriate lift of the core curve in the
+        # hyperboloid model.
+        tet.core_curves = { }
+
+    # For each cusp, a pair of words for the meridian and longitude as
+    # sequence of non-zero integers.
+    #
+    # Only computed when needed.
+    all_peripheral_words : Optional[Sequence[Sequence[Sequence[int]]]] = None
+    for v, info in zip(mcomplex.Vertices, manifold.cusp_info()):
+        if v.filling_matrix[0] != (0,0):
+            if all_peripheral_words is None:
+                # Make the SnapPea kernel compute peripheral curves the first
+                # time when we need them.
+                G = manifold.fundamental_group(False)
+                all_peripheral_words = G.peripheral_curves(as_int_list=True)
+            # Note that a cusp only determines the words for the meridian
+            # and longitude only up to conjugacy, we need to pick a lift of the
+            # cusp and a path from the basepoint to the lift.
+            #
+            # Similarly, the lift of the core curve of a filled cusp to the
+            # hyperboloid model depends on a lift of a cusp a path from the
+            # basepoint to the lift.
+            #
+            # We compute the lift for each vertex of each tetrahedron in the
+            # fundamental domain corresponding to the cusp (with the path
+            # connecting the basepoint to the vertex being the one contained
+            # in the fundamental domain).
+            #
+            # Starting with the one choice the SnapPea kernel did and computing
+            # the resulting lift of the core curve, we need to transfer it
+            # to the other choices of vertices of tetrahedra corresponding to
+            # the cusp by "developing" the cusp.
+            #
+            _develop_core_curve_cusp(
+                mcomplex,
+                v,
+                _compute_core_curve(
+                    mcomplex,
+                    all_peripheral_words[v.Index],
+                    v.filling_matrix[1]))
+
+
+###############################################################################
+# Helpers
+
+def _compute_core_curve(
+        mcomplex : Mcomplex,
+        peripheral_words : Sequence[Sequence[int]],
+        core_curve_coefficients : Filling) -> R13LineWithMatrix:
+    """
+    Compute core curve given words for meridian and longitude and
+    the integers determining a curve (as sum of a multiple of meridian
+    and longitude) that is parallel to the core curve.
+    """
+
+    result = mcomplex.GeneratorMatrices[0]
+
+    for word, f in zip(peripheral_words, core_curve_coefficients):
+        if f != 0:
+            m = word_list_to_psl2c_matrix(mcomplex, word)
+            if f < 0:
+                m = sl2c_inverse(m)
+            for i in range(abs(f)):
+                result = result * m
+
+    return r13_fixed_line_of_psl2c_matrix(result)
+
+def _find_standard_basepoint(mcomplex : Mcomplex,
+                             vertex : Vertex) -> Tuple[Tetrahedron, int]:
+    """
+    Reimplements find_standard_basepoint in fundamental_group.c.
+
+    That is, it finds the same tetrahedron and vertex of that tetrahedron
+    in the fundamental domain that the SnapPea kernel used to compute the
+    words for the meridian and longitude of the given cusp.
+
+    The SnapPea kernel picks the first vertex it finds where the meridian
+    and longitude intersect.
+    """
+
+    # Traverse tets and their vertices in the same order the SnapPea kernel
+    # does
+    for tet in mcomplex.Tetrahedra:
+        for v in simplex.ZeroSubsimplices:
+            # Only consider vertices corresponding to the given cusp
+            if tet.Class[v] is vertex:
+                for f in simplex.TwoSubsimplices:
+                    # Check that the meridian and longitude both
+                    # go through the same leg of the spine of the cusp
+                    # triangle.
+                    #
+                    # Note that we only support orientable manifolds,
+                    # so we only consider the 0-sheet of the orientation
+                    # double-cover of the cusp triangulation.
+                    if (tet.PeripheralCurves[0][0][v][f] != 0 and
+                        tet.PeripheralCurves[1][0][v][f] != 0):
+                        return tet, v
+
+    raise Exception("Could not find basepoint for cusp. This is a bug.")
+
+
+def _develop_core_curve_cusp(
+        mcomplex : Mcomplex,
+        v : Vertex,
+        core_curve : R13LineWithMatrix) -> None:
+    """
+    Given the core curve computed from the SnapPea kernel's given
+    words for the meridian and longitude for the given cusp,
+    compute the lift of the core curve for all vertices of the
+    tetrahedra corresponding to the given cusp.
+    """
+
+    # Start with the tet and vertex that the SnapPea kernel used
+    # to compute the words.
+    tet, vertex = _find_standard_basepoint(mcomplex, v)
+
+    tet.core_curves[vertex] = core_curve
+    pending_tet_verts = deque([ (tet, vertex, core_curve) ])
+
+    # Breadth-first traversal of cusp triangles to compute appropriate
+    # transform of core curve.
+    while pending_tet_verts:
+        tet, vertex, core_curve = pending_tet_verts.popleft()
+        for f in simplex.FacesAroundVertexCounterclockwise[vertex]:
+            new_tet = tet.Neighbor[f]
+            new_vertex = tet.Gluing[f].image(vertex)
+            if new_vertex in new_tet.core_curves:
+                continue
+            new_core_curve = core_curve.transformed(tet.O13_matrices[f])
+            new_tet.core_curves[new_vertex] = new_core_curve
+            pending_tet_verts.append(
+                (new_tet, new_vertex, new_core_curve))