snappy 3.1.1__cp38-cp38-win_amd64.whl → 3.2__cp38-cp38-win_amd64.whl

snappy/{drilling/geodesic_info.py → geometric_structure/geodesic/geodesic_start_point_info.py}

@@ -1,18 +1,27 @@
-from .line import R13LineWithMatrix
-from . import epsilons
 from . import constants
 from . import exceptions
 
-from ..hyperboloid import r13_dot, o13_inverse, distance_unit_time_r13_points # type: ignore
-from ..snap.t3mlite import simplex # type: ignore
-from ..snap.t3mlite import Tetrahedron, Vertex, Mcomplex # type: ignore
-from ..exceptions import InsufficientPrecisionError # type: ignore
-from ..matrix import matrix # type: ignore
+from .line import R13LineWithMatrix
+from .fixed_points import r13_fixed_line_of_psl2c_matrix
+from .multiplicity import compute_and_verify_multiplicity
+from .graph_trace_helper import find_lifted_tetrahedra_containing_point
+
+from .. import word_to_psl2c_matrix
+
+from ...tiling.lifted_tetrahedron import LiftedTetrahedron
+from ...hyperboloid import r13_dot, o13_inverse # type: ignore
+from ...hyperboloid.distances import distance_r13_points
+from ...hyperboloid.line import R13Line
+from ...snap.t3mlite import simplex # type: ignore
+from ...snap.t3mlite import Tetrahedron, Vertex, Mcomplex # type: ignore
+from ...exceptions import InsufficientPrecisionError # type: ignore
+from ...matrix import make_identity_matrix # type: ignore
 
 from typing import Tuple, Sequence, Optional, Any
 
+__all__ = ['compute_geodsic_info', 'GeodesicStartPointInfo', 'sample_line']
 
-def sample_line(line_with_matrix : R13LineWithMatrix):
+def sample_line(line : R13Line):
     """
     Pick a point on a line in the hyperboloid model.
     Returns an unnormalised time-like vector computed
@@ -24,9 +33,18 @@ def sample_line(line_with_matrix : R13LineWithMatrix):
     triangulation (which happens for some geodesics in some
     triangulated hyperbolic manifolds when picking equal weights for
     the fixed points computed by r13_fixed_points_of_psl2c_matrix).
+
+    Note that we want to avoid picking a point that is far away from
+    the fundamental polyhedron. By the choices we made, this is not
+    the case: the fundamental polyhedron is contains the origin in the
+    hyperboloid model. r13_fixed_points_of_psl2c_matrix returns
+    light-like vectors of the form (1, ...) so the average corresponds
+    to taking the mid-point in the Klein model and is thus the point
+    on the line closest to the origin. Furthermore, the bias is close
+    enough to 1 (the log is ~0.22, so we move the point by ~0.11
+    units in hyperbolic space).
     """
 
-    line = line_with_matrix.r13_line
     RF = line.points[0][0].parent()
     bias = RF(constants.start_point_bias)
 
@@ -35,29 +53,7 @@ def sample_line(line_with_matrix : R13LineWithMatrix):
 # @dataclass
 
 
-class LiftedTetrahedron:
-    """
-    Represents the lift of a tetrahedron in a manifold to the hyperboloid
-    model.
-
-    That is, if a tetrahedron (as part of the fundamental domain) was assigned
-    vertices by calling add_r13_geometry, then the vertices of a
-    LiftedTetrahedron l will be given by l.o13_matrices * tet.R13_vertices[v]
-    where v in snappy.snap.t3mlite.simplex.ZeroSubsimplices.
-    """
-
-    def __init__(self,
-                 tet : Tetrahedron,
-                 # An O(1,3)-matrix - since this might be a SageMath class or a
-                 # SimpleMatrix, just using Any as type annotation.
-                 o13_matrix):
-        self.tet = tet
-        self.o13_matrix = o13_matrix
-
-# @dataclass
-
-
-class GeodesicInfo:
+class GeodesicStartPointInfo:
     """
     Information needed to trace a closed geodesic through a triangulation
     given as snappy.snap.t3mlite.Mcomplex with geometric structure added
@@ -74,7 +70,7 @@ class GeodesicInfo:
     will either:
 
     1. Detect that the closed geodesic is actually a core curve of a
-       filled cusp and set core_curve_cusp and core_curve_direction
+       filled cusp and set core_curve_cusp and core_curve_multiplicity
        accordingly. This means that instead tracing the geodesic
        through the triangulation, the client has to unfill the
        corresponding cusp instead.
@@ -104,6 +100,9 @@ class GeodesicInfo:
                  # The triangulation
                  mcomplex : Mcomplex,
 
+                 # Word were are drilling
+                 word : str,
+                 
                  # Trace of corresponding PSL(2,C)-matrix.
                  trace : Any,
 
@@ -143,13 +142,14 @@ class GeodesicInfo:
                  # Output of find_tet_or_core_corve: sign (+1/-1) indicating whether
                  # the given geodesic and the core curve run parallel or
                  # anti-parallel.
-                 core_curve_direction : int = 0,
+                 core_curve_multiplicity : Optional[int] = None,
 
                  # Field filled by client to indicate which index the cusp resulting
                  # from drilling this geodesic is supposed to have.
                  index : Optional[int] = None):
 
         self.mcomplex = mcomplex
+        self.word = word
         self.trace = trace
         self.unnormalised_start_point = unnormalised_start_point
         self.unnormalised_end_point = unnormalised_end_point
@@ -157,7 +157,7 @@ class GeodesicInfo:
         self.tet = tet
         self.lifted_tetrahedra = lifted_tetrahedra
         self.core_curve_cusp = core_curve_cusp
-        self.core_curve_direction = core_curve_direction
+        self.core_curve_multiplicity = core_curve_multiplicity
         self.index = index
 
     def find_tet_or_core_curve(self) -> None:
@@ -172,10 +172,13 @@ class GeodesicInfo:
         not ensure that this distance is positive.
         """
 
+        self._graph_trace()
+
+    def _graph_trace(self):
         self.tet = None
         self.lifted_tetrahedra = ()
         self.core_curve_cusp = None
-        self.core_curve_direction = 0
+        self.core_curve_multiplicity = None
 
         # Walks from tetrahedron to tetrahedron (transforming the start point
         # and other data) trying to get the start_point closer and closer to
@@ -184,111 +187,36 @@ class GeodesicInfo:
         # face of a tetrahedron or when (the lift of) the geodesic was really
         # close to (a lift of) a core curve.
 
-        # tet is the tetrahedron where the algorithm stopped.
-        # faces is the subset of simplex.TwoSubsimplices: a face is in the subset
-        # if it could not be verified that the start point is to the inside
-        # of the plane supporting that face.
-        # cusp_curve_vertex is None or an element of simplex.ZeroSubsimplices
-        # if we are close to the core curve at that vertex.
-        tet, faces, cusp_curve_vertex = self._graph_trace(self.mcomplex.baseTet)
-
-        # Do some verification work for the above information to fill
-        # self.tet, self.lifted_tetrahedra and self.core_curve_cusp.
-
-        if cusp_curve_vertex is not None:
-            # Verify that the the geodesic is really the core curve and
-            # determine whether the geodesic and core curve or parallel
-            # or anti-parallel.
-            self.core_curve_direction = self._verify_direction_of_core_curve(
-                tet, cusp_curve_vertex)
-            self.core_curve_cusp = tet.Class[cusp_curve_vertex]
-            return
-
-        id_matrix = matrix.identity(ring=self.mcomplex.RF, n=4)
-
-        if len(faces) == 0:
-            # The start point is really inside the given tetrahedron.
-
-            # Signal to the client that we can start tracing the geodesic
-            # throguh the triangulation from this tetrahedron:
-            self.tet = tet
-
-            # Signal to the client that we can start with this tetrahedron
-            # when developing a tube about the geodesic.
-            self.lifted_tetrahedra = [ LiftedTetrahedron(tet, id_matrix) ]
-            return
-
-        if len(faces) == 1:
-            # The start point is probably on the face of the tetrahedron,
-            # that is, we could verify it lies to the right side of the
-            # supporting planes for three faces but not one:
-            face, = faces
-
-            # Even though we cannot verify that the start point lies
-            # exactly on the face, we can verify that the start point
-            # lies in the interior of the union of two neighboring
-            # tetrahedra. That is, the union is a hexahedron and
-            # it suffices to check that the start point lies to the
-            # inside of the six faces of the tetrahedron.
-            #
-            # _graph_trace already checked the three faces of the given
-            # tetrahedron. But it is left to check this for the neighboring
-            # tetrahedron.
-
-            # Find the other tetrahedron of the neighboring tetrahedra.
-            other_tet = tet.Neighbor[face]
-            other_unnormalised_start_point = (
-                tet.O13_matrices[face] * self.unnormalised_start_point)
-            other_face = tet.Gluing[face].image(face)
-
-            for f in simplex.TwoSubsimplices:
-                if f != other_face:
-                    if not r13_dot(other_unnormalised_start_point,
-                                   other_tet.R13_planes[f]) < 0:
-                        raise InsufficientPrecisionError(
-                            "Failed to find lift of geodesic and prove that "
-                            "it intersects tetrahedra of the fundamental domain. "
-                            "Increasing the precision will probably fix this "
-                            "problem.")
-
-            # Returns the two (lifted) tetrahedra.
-            self.lifted_tetrahedra = [
-                LiftedTetrahedron(tet, id_matrix),
-                LiftedTetrahedron(other_tet,
-                                  other_tet.O13_matrices[other_face]) ]
-            return
-
-        raise InsufficientPrecisionError(
-            "Start point chosen on geodesic too close to 1-skeleton of "
-            "triangulation to verify it is not on the 1-skeleton. "
-            "Increasing the precision will probably fix this problem.")
-
-    def _graph_trace(
-            self,
-            tet : Tetrahedron) -> Tuple[Tetrahedron,
-                                        Sequence[int],
-                                        Optional[int]]:
-        """
-        Walk from tetrahedron to tetrahedron (transforming start point and
-        the other data) to capture the start point in a tetrahedron.
-        """
-
         if self.mcomplex.verified:
             epsilon = 0
-            key = _graph_trace_key_verified
+            def key(face_and_signed_distance):
+                return face_and_signed_distance[1].center()
         else:
-            epsilon = epsilons.compute_epsilon(self.mcomplex.RF)
-            key = _graph_trace_key
+            epsilon = _compute_epsilon(self.mcomplex.RF)
+            def key(face_and_signed_distance):
+                return face_and_signed_distance[1]
 
         # Face through which tetrahedron was entered - to avoid we are
         # going back through the face we just came from. Initialized to
         # simplex.T for the first iteration.
+        tet = self.mcomplex.baseTet
         entry_cell = simplex.T
 
         for i in range(constants.graph_trace_max_steps):
             # See whether the geodesic is close to a core curve.
+            # v is the vertex of the simplex for that core curve.
+            # Or None
             v = self._find_cusp_if_core_curve(tet, entry_cell, epsilon)
 
+            if v is not None:
+                # Verify that the the geodesic is really the core curve and
+                # determine whether the geodesic and core curve or parallel
+                # or anti-parallel.
+                self.core_curve_multiplicity = self._multiplicity_of_core_curve(
+                    tet, v)
+                self.core_curve_cusp = tet.Class[v]
+                return
+
             # Compute the signed distance of the start point to the
             # planes supporting a face for each face of the tetrahedron.
             #
@@ -308,22 +236,29 @@ class GeodesicInfo:
             # tetrahedron, stop.
             #
             # Note the subtle difference here between using
-            # signed_distance > epsilon to determine whether to stop
+            # signed_distance >  epsilon to determine whether to stop
             # signed_distance < -epsilon to determine whether the start point
             # is inside.
             #
-            if v or not any( signed_distance > epsilon
-                             for face, signed_distance
-                             in faces_and_signed_distances ):
-
-                # Report faces for which we cannot confirm that the start point
-                # is to the inside of the plane supporting that face.
-                return (tet,
-                        [ face
-                          for face, signed_distance
-                          in faces_and_signed_distances
-                          if not signed_distance < -epsilon ],
-                        v)
+            if not any( signed_distance > epsilon
+                        for face, signed_distance
+                        in faces_and_signed_distances ):
+
+                self.lifted_tetrahedra = find_lifted_tetrahedra_containing_point(
+                    LiftedTetrahedron(
+                        tet, make_identity_matrix(ring=self.mcomplex.RF, n=4)),
+                    faces_and_signed_distances,
+                    self.unnormalised_start_point,
+                    epsilon)
+
+                if len(self.lifted_tetrahedra) == 1:
+                    # We verified that there is a unique tetrahedron containing
+                    # the start point.
+                    # Signal to the client that we can start tracing the geodesic
+                    # throguh the triangulation from this tetrahedron:
+                    self.tet = self.lifted_tetrahedra[0].tet
+
+                return
 
             # Find face for which the signed distance is largest.
             #
@@ -422,12 +357,12 @@ class GeodesicInfo:
 
         return None
 
-    def _verify_direction_of_core_curve(self,
-                                        tet : Tetrahedron,
-                                        vertex : int) -> int:
+    def _multiplicity_of_core_curve(self,
+                                    tet : Tetrahedron,
+                                    vertex : int) -> int:
         """
-        Verify that geodesic and core curve are indeed the same and
-        return sign indicating whether they are parallel or anti-parallel.
+        Verify that geodesic is indeed a multiple of the core curve (including
+        sign).
         """
 
         if self.line is None:
@@ -435,42 +370,66 @@ class GeodesicInfo:
                 "There is a bug in the code: it is trying to verify that "
                 "geodesic is a core curve without being given a line.")
 
-        # We do this by checking whether the corresponding
-        # Decktransformations corresponding to each are the same.
-
-        # To check whether two Decktransformations are the same, we let each
-        # act on the basepoint (which is the incenter of the base tetrahedron)
-        # and compute the distance between the two images.
-        # We know that the ball about the basepoint with radius the inradius
-        # of the base tetrahedron injects into the manifold. Thus,
-        # the distance between the two images is either 0 or larger than
-        # two times the inradius.
-        # Hence, if we can prove the distance to be less than the inradius,
-        # we know that the two Decktransformations are the same.
-
-        # Decktransformation corresponding geodesic acting on basepoint
-        a = self.line.o13_matrix * self.mcomplex.R13_baseTetInCenter
-
-        # Decktransformation corresponding to core curve acting on basepoint
-        m = tet.core_curves[vertex].o13_matrix
-        b0 = m * self.mcomplex.R13_baseTetInCenter
-        if distance_unit_time_r13_points(a, b0) < self.mcomplex.baseTetInRadius:
-            return +1
-
-        # Decktransformation corresponding to core curve with opposite
-        # orientation acting on basepoint.
-        b1 = o13_inverse(m) * self.mcomplex.R13_baseTetInCenter
-        if distance_unit_time_r13_points(a, b1) < self.mcomplex.baseTetInRadius:
-            return -1
+        try:
+            return compute_and_verify_multiplicity(
+                tet.core_curves[vertex],
+                self.line,
+                self.mcomplex)
+        except InsufficientPrecisionError:
+            raise InsufficientPrecisionError(
+                "Geodesic is very close to a core curve but could not verify "
+                "it is the core curve. Increasing the precision will probably "
+                "fix this.")
+
+def compute_geodesic_start_point_info(mcomplex : Mcomplex,
+                          word) -> GeodesicStartPointInfo:
+    """
+    Compute basic information about a geodesic given a word.
 
-        raise InsufficientPrecisionError(
-            "Geodesic is very close to a core curve but could not verify it is "
-            "the core curve. Increasing the precision will probably fix this.")
+    add_r13_geometry must have been called on the Mcomplex.
+    """
 
+    m = word_to_psl2c_matrix(mcomplex, word)
+    _verify_not_parabolic(m, mcomplex, word)
+    # Line fixed by matrix
+    line : R13LineWithMatrix = r13_fixed_line_of_psl2c_matrix(m)
+
+    # Pick a point on the line
+    start_point = sample_line(line.r13_line)
+
+    g = GeodesicStartPointInfo(
+        mcomplex=mcomplex,
+        word=word,
+        trace=m.trace(),
+        unnormalised_start_point=start_point,
+        unnormalised_end_point=line.o13_matrix * start_point,
+        line=line)
+
+    # Determines whether geodesic corresponds to a core curve.
+    # Applies Decktransformations so that start point lies within
+    # the interior of one tetrahedron in the fundamental domain or
+    # within the union of two tetrahedra neighboring in the hyperboloid
+    # model.
+    #
+    # See GeodesicStartPointInfo for details.
+    g.find_tet_or_core_curve()
+
+    return g
+
+def _verify_not_parabolic(m, mcomplex, word):
+    """
+    Raise exception when user gives a word corresponding to a parabolic
+    matrix.
+    """
 
-def _graph_trace_key(face_and_signed_distance):
-    return face_and_signed_distance[1]
+    if mcomplex.verified:
+        epsilon = 0
+    else:
+        epsilon = _compute_epsilon(mcomplex.RF)
 
+    tr = m.trace()
+    if not (abs(tr - 2) > epsilon and abs(tr + 2) > epsilon):
+        raise exceptions.WordAppearsToBeParabolic(word, tr)
 
-def _graph_trace_key_verified(face_and_signed_distance):
-    return face_and_signed_distance[1].center()
+def _compute_epsilon(RF):
+    return RF(0.5) ** (RF.prec() // 2)

snappy/geometric_structure/geodesic/graph_trace_helper.py

@@ -0,0 +1,67 @@
+from ...tiling.lifted_tetrahedron import LiftedTetrahedron
+from ...snap.t3mlite import simplex # type: ignore
+from ...hyperboloid import r13_dot
+from ...exceptions import InsufficientPrecisionError # type: ignore
+
+def find_lifted_tetrahedra_containing_point(
+        lifted_tetrahedron : LiftedTetrahedron,
+        faces_and_signed_distances,
+        lifted_pt,
+        epsilon):
+
+    # Report faces for which we cannot confirm that the start point
+    # is to the inside of the plane supporting that face.
+    faces = [ face
+              for face, signed_distance
+              in faces_and_signed_distances
+              if not signed_distance < -epsilon ]
+
+    if len(faces) == 0:
+        # Signal to the client that we can start with this tetrahedron
+        # when developing a tube about the geodesic.
+        return [ lifted_tetrahedron ]
+
+    if len(faces) == 1:
+        # The start point is probably on the face of the tetrahedron,
+        # that is, we could verify it lies to the right side of the
+        # supporting planes for three faces but not one:
+        face, = faces
+
+        # Even though we cannot verify that the start point lies
+        # exactly on the face, we can verify that the start point
+        # lies in the interior of the union of two neighboring
+        # tetrahedra. That is, the union is a hexahedron and
+        # it suffices to check that the start point lies to the
+        # inside of the six faces of the tetrahedron.
+        #
+        # _graph_trace already checked the three faces of the given
+        # tetrahedron. But it is left to check this for the neighboring
+        # tetrahedron.
+
+        tet = lifted_tetrahedron.tet
+        m = lifted_tetrahedron.o13_matrix
+
+        # Find the other tetrahedron of the neighboring tetrahedra.
+        other_tet = tet.Neighbor[face]
+        other_pt = tet.O13_matrices[face] * lifted_pt
+        other_face = tet.Gluing[face].image(face)
+
+        for f in simplex.TwoSubsimplices:
+            if f == other_face:
+                continue
+            if not r13_dot(other_pt, other_tet.R13_planes[f]) < epsilon:
+                raise InsufficientPrecisionError(
+                    "Failed to find lift of geodesic and prove that "
+                    "it intersects tetrahedra of the fundamental domain. "
+                    "Increasing the precision will probably fix this "
+                    "problem.")
+
+        return [ lifted_tetrahedron,
+                 LiftedTetrahedron(
+                     other_tet,
+                     m * other_tet.O13_matrices[other_face]) ]
+
+    raise InsufficientPrecisionError(
+        "Start point chosen on geodesic too close to 1-skeleton of "
+        "triangulation to verify it is not on the 1-skeleton. "
+        "Increasing the precision will probably fix this problem.")

snappy/geometric_structure/geodesic/line.py

@@ -0,0 +1,30 @@
+from ...hyperboloid import o13_inverse # type: ignore
+from ...hyperboloid.line import R13Line
+
+__all__ = [ 'R13LineWithMatrix' ]
+
+class R13LineWithMatrix:
+    """
+    A line in the hyperboloid model together with a O(1,3)-matrix moving
+    the line forward by the given complex length (with real positive part)
+    (the matrix is fixing the line set-wise).
+    """
+    def __init__(self,
+                 r13_line : R13Line,
+                 o13_matrix,
+                 complex_length):
+        self.r13_line = r13_line
+        self.o13_matrix = o13_matrix
+        self.complex_length = complex_length
+
+    def transformed(self, m):
+        """
+        Returns image of line with matrix under given O13-matrix m.
+
+        That is, the matrix will be conjugated by m so that the new
+        matrix will fix the image of the line (set-wise).
+        """
+        return R13LineWithMatrix(
+            self.r13_line.transformed(m),
+            m * self.o13_matrix * o13_inverse(m),
+            self.complex_length)

snappy/geometric_structure/geodesic/multiplicity.py

@@ -0,0 +1,127 @@
+from .line import R13LineWithMatrix
+from ...hyperboloid.distances import distance_r13_points
+from ...hyperboloid import o13_inverse
+from ...exceptions import InsufficientPrecisionError
+
+def compute_and_verify_multiplicity(line : R13LineWithMatrix,
+                                    line_power : R13LineWithMatrix,
+                                    mcomplex):
+    """
+    Assume that line and line_power are created from matrices from the geometric
+    representation.
+
+    Verify that the matrix of line_power is a signed multiple of the matrix
+    of line and return the multiple.
+    """
+
+    # First use real length to compute multiple up to sign.
+    multiplicity = _compute_absolute_multiplicity(
+        line.complex_length.real(),
+        line_power.complex_length.real(),
+        mcomplex.verified)
+
+    sign = _determine_and_verify_sign(
+        multiplicity,
+        line.o13_matrix,
+        line_power.o13_matrix,
+        mcomplex)
+    
+    return sign * multiplicity
+
+_epsilon = 0.001
+_max_multiple = 500
+
+def _compute_absolute_multiplicity(
+        length,
+        length_multiple,
+        verified):
+
+    r = length_multiple / length
+
+    if verified:
+        is_int, r_int = r.is_int()
+        if not is_int:
+            raise InsufficientPrecisionError(
+                "When verifying that a geodesic is a multiple of another "
+                "geodesic, the interval for the multiplicity does not contain "
+                "a unique integer.")
+    else:
+        r_int = r.round()
+        if abs(r_int - r) > _epsilon:
+            raise InsufficientPrecisionError(
+                "When verifying that a geodesic is a multiple of another "
+                "geodesic, the floating point approximation for the "
+                "multiplicity is too far off an integer.")
+        r_int = int(r_int)
+
+    if not r_int > 0:
+        if verified:
+            raise RuntimeError(
+                "When verifying that a geodesic is a multiple of another "
+                "geodesic, we got zero for multiplicity. This is a bug.")
+        else:
+            raise InsufficientPrecisionError(
+                "When verifying that a geodesic is a multiple of another "
+                "geodesic, we got zero for multiplicity. Increasing the "
+                "precision might help.")
+    if not r_int < _max_multiple:
+        raise RuntimeError(
+            "When verifying that a geodesic is a multiple of another "
+            "geodesic, we got a multiple (%d) higher than what we support "
+            "(%d)" % (r_int, _max_multiple))
+
+    return r_int
+
+def _determine_and_verify_sign(multiplicity, m, m_power, mcomplex):
+    """
+    Given matrices m and m_power coming from the geometric representation,
+    verify that either m^multiplicity = m_power^sign for either sign = +1
+    or sign = -1. Return sign.
+    """
+
+    base_pt = mcomplex.R13_baseTetInCenter
+
+    # Compute image of base point under m^multiplicity.
+    pt = base_pt
+    for i in range(multiplicity):
+        pt = m * pt
+
+    # Check whether it is equal to image under m_power
+    if _are_images_of_basepoints_equal(
+            pt,             m_power  * base_pt, mcomplex):
+        return +1
+
+    # Check whether it is equal to image under m_power^-1
+    if _are_images_of_basepoints_equal(
+            pt, o13_inverse(m_power) * base_pt, mcomplex):
+        return -1
+
+    raise RuntimeError(
+        "Given geodesic is not a multiple of other given geodesic.")
+
+def _are_images_of_basepoints_equal(pt0, pt1, mcomplex):
+    """
+    Given two images of the base point under Deck transformations,
+    check whether they are the same (and thus correspond to the same
+    Deck transformation).
+    """
+
+    # We use that the the base point is the incenter of the base
+    # tetrahedron. Thus, we know that if the minimum distance for
+    # them to be distinct is the in-radius of the base tetrahedron.
+    #
+    # We add in a factor of 1/2 for safety.
+
+    d = distance_r13_points(pt0, pt1)
+    if d < mcomplex.baseTetInRadius / 2:
+        return True
+    if d > mcomplex.baseTetInRadius / 2:
+        return False
+
+    raise InsufficientPrecisionError(
+        "When determining whether a geodesic is a multiple of another "
+        "geodesic, we could not verify that the images of the base point "
+        "under the corresponding matrices are the same or not.\n"
+        "Distance between basepoints: %r\n"
+        "Cut-off: %r" % (d, mcomplex.baseTetInRadius / 2))
+