snappy 3.1.1__cp310-cp310-win_amd64.whl → 3.2__cp310-cp310-win_amd64.whl

snappy/drilling/crush.py

@@ -1,23 +1,20 @@
 from .cusps import CuspPostDrillInfo
-from .tracing import GeodesicPiece
 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 Dict, Tuple, List, Sequence
-
+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 tetrahedra in the
-    barycentric subdivision that are adjacent to an edge that coincides with a
-    GeodesicPiece.
+    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.
 
-    That is, the given tetrahedra are supposed to form a triangulation and
-    have GeodesicPiece's stored in tet.geodesic_pieces such that all endpoints
-    of all pieces are at vertices of the tetrahedron, that is the line
-    segment the GeodesicPiece represents is an edge of the tetrahedron.
+    The function mark_subtetrahedra_about_geodesic_pieces marks the
+    subtetrahedra as described above.
     """
 
     # We call the tetrahedra in the barycentric subdivision subtetrahedra
@@ -38,16 +35,17 @@ def crush_geodesic_pieces(tetrahedra : Sequence[Tetrahedron]) -> Mcomplex:
     # Using the index i that p has in Perm4.S4, we index
     # a subtetrahedron by 24 * tet.Index + i.
 
-    # Compute a bit mask of which subtetrahedra in the barycentric
-    # subdivision will not be crushed.
+    # The subtetrahedra that are supposed to be curshed in the barycentric
+    # are assumed to be marked in tet.marked_subtetrahedra.
     #
-    # Also pick a subtetrahedron for each simple closed curve that we can
-    # use later to compute a new meridian and longitude.
-    mask, peripheral_base_subtet_indices = (
-        _tet_mask_and_peripheral_base_subtet_indices(tetrahedra))
+    # 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 m else None for m in mask ]
+    subtetrahedra = [
+        Tetrahedron() if marked_subtet == 0 else None
+        for tet in tetrahedra
+        for marked_subtet in tet.marked_subtetrahedra ]
 
     _assign_orientations(subtetrahedra)
 
@@ -64,10 +62,10 @@ def crush_geodesic_pieces(tetrahedra : Sequence[Tetrahedron]) -> Mcomplex:
             # 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_perm = perm * transpositions[face]
+                j = perm_to_index(other_perm)
                 other_subtet_index = 24 * tet.Index + j
-                if face == 1 and not mask[other_subtet_index]:
+                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.
@@ -89,7 +87,7 @@ def crush_geodesic_pieces(tetrahedra : Sequence[Tetrahedron]) -> Mcomplex:
                     # 0============1============0
                     #
                     other_perm = perm * Perm4((2,1,0,3))
-                    j = _perm_to_index(other_perm)
+                    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
@@ -104,12 +102,12 @@ def crush_geodesic_pieces(tetrahedra : Sequence[Tetrahedron]) -> Mcomplex:
             face = perm.image(simplex.F3)
             other_tet = tet.Neighbor[face]
             other_perm = tet.Gluing[face] * perm
-            j = _perm_to_index(other_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))
+                              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
@@ -186,11 +184,41 @@ def crush_geodesic_pieces(tetrahedra : Sequence[Tetrahedron]) -> Mcomplex:
 
     _fix_all_peripheral_curves(subtetrahedra)
 
-    # Find peripheral curves for the cusps created by crushing the simple
+    # Find peripheral curves for each cusps created by crushing the simple
     # closed curves.
-    for i in peripheral_base_subtet_indices:
-        install_peripheral_curves(subtetrahedra[i])
-
+    # 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
@@ -200,108 +228,6 @@ def crush_geodesic_pieces(tetrahedra : Sequence[Tetrahedron]) -> Mcomplex:
                       for subtet in subtetrahedra
                       if subtet and subtet.orientation == s ])
 
-
-_perm_tuple_to_index : Dict[Tuple[int, int, int, int], int] = {
-    perm.tuple() : i for i, perm in enumerate(Perm4.S4()) }
-
-_transpositions : List[Perm4] = [ Perm4((1,0,2,3)),
-                                  Perm4((0,2,1,3)),
-                                  Perm4((0,1,3,2)) ]
-
-
-def _perm_to_index(perm : Perm4) -> int:
-    return _perm_tuple_to_index[perm.tuple()]
-
-
-def _find_perm_for_piece(piece : GeodesicPiece):
-    """
-    Given a GeodesicPiece with endpoints being on the vertices
-    of the tetrahedron and spanning an oriented edge of the tetrahedron,
-    find an "edge embedding permutation" (similar to regina's
-    edge embedding) that maps the 0-1 edge to the given edge.
-
-    The subtetrahedron corresponding to this permutation is
-    adjacent to half of this edge.
-    """
-
-    s0 = piece.endpoints[0].subsimplex
-    s1 = piece.endpoints[1].subsimplex
-
-    # Important to consistently always pick a permutation of the
-    # same parity and respect the ordering of the vertices V0 and V1
-    # since this affects which subtetrahedron will be chosen as peripheral
-    # base subtetrahedron - and thus ultimately affects the orientation
-    # of the meridian and longitude computed by install_peripheral_curves.
-    for perm in Perm4.A4():
-        if perm.image(simplex.V0) == s0 and perm.image(simplex.V1) == s1:
-            return perm
-
-
-def _traverse_edge(tet0 : Tetrahedron, perm0 : Perm4, mask : List[bool]):
-    """
-    Given a subtetrahedron in the barycentric subdivision parametrized
-    by a tetrahedron and permutation, find all subtetrahedra adjacent to the
-    same edge in the original triangulation. Delete them from the bit mask.
-    """
-
-    tet = tet0
-    perm = perm0
-
-    while True:
-        # All subtetrahedra touching the same edge in the current
-        # tetrahedron.
-        for p in [ perm,
-                   perm * _transpositions[0],
-                   perm * _transpositions[2],
-                   perm * _transpositions[0] * _transpositions[2] ]:
-            subtet_index = 24 * tet.Index + _perm_to_index(p)
-            mask[subtet_index] = False
-
-        # Find the next "edge embedding"
-        face = perm.image(simplex.F3)
-        tet, perm = (
-            tet.Neighbor[face],
-            tet.Gluing[face] * perm * Perm4((0,1,3,2)))
-        # Stop if back at the first "edge embedding"
-        if tet is tet0 and perm.tuple() == perm0.tuple():
-            return
-
-
-def _tet_mask_and_peripheral_base_subtet_indices(tetrahedra):
-    """
-    Given the same input as described in crush_geodesic_data,
-    computes the bit mask of which subtetrahedra will not be
-    crushed. Also return a set of indices, that is the index
-    of one subtetrahedron for each simple closed curve that
-    can be used later to compute a new meridian and longitude.
-    """
-
-    # The bit mask to compute
-    mask = (24 * len(tetrahedra)) * [ True ]
-
-    # Maps index of simple closed curve to index of subtetrahedron
-    index_to_peripheral_base_subtet_index = { }
-
-    # For each GeodesicPiece
-    for tet in tetrahedra:
-        for piece in tet.geodesic_pieces:
-            # Find all subtetrahedra adjacent to it to delete
-            # them from mask
-            perm = _find_perm_for_piece(piece)
-
-            _traverse_edge(tet, perm, mask)
-
-            # And if this is the first time we encounter this
-            # simple closed curve, compute a base tet.
-            if piece.index not in index_to_peripheral_base_subtet_index:
-                # Get the neighboring subtetrahedron that won't be crushed
-                other_perm = perm * _transpositions[1]
-                subtet_index = 24 * tet.Index + _perm_to_index(other_perm)
-                index_to_peripheral_base_subtet_index[piece.index] = subtet_index
-
-    return mask, index_to_peripheral_base_subtet_index.values()
-
-
 def _assign_orientations(subtetrahedra):
     for j in range(len(subtetrahedra) // 24):
         for i, perm in enumerate(Perm4.S4()):

snappy/drilling/cusps.py

@@ -1,8 +1,10 @@
-from .geodesic_info import GeodesicInfo
-from .geometric_structure import Filling, FillingMatrix
+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
@@ -49,11 +51,11 @@ class CuspPostDrillInfo:
 
 
 def index_geodesics_and_add_post_drill_infos(
-        geodesics : Sequence[GeodesicInfo],
+        geodesics : Sequence[GeodesicStartPointInfo],
         mcomplex : Mcomplex) -> None:
 
-    all_reindexed_verts = set(
-        g.core_curve_cusp for g in geodesics if g.core_curve_cusp)
+    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]
@@ -66,11 +68,15 @@ def index_geodesics_and_add_post_drill_infos(
 
     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_direction))
+                    g.core_curve_multiplicity))
         else:
             g.index = n + i
 

snappy/drilling/debug.py

@@ -1,4 +1,5 @@
 from ..snap.t3mlite import simplex
+from ..matrix import make_identity_matrix
 from ..hyperboloid import *
 
 
@@ -82,7 +83,7 @@ def check_points_consistency(m):
 
 def check_edge_consistency(m):
     RF = m.Tetrahedra[0].O13_matrices[simplex.F0].base_ring()
-    id_matrix = matrix.identity(ring=RF, n=4)
+    id_matrix = make_identity_matrix(ring=RF, n=4)
 
     for e in m.Edges:
         t = id_matrix

snappy/drilling/exceptions.py

@@ -1,17 +1,6 @@
 class DrillGeodesicError(RuntimeError):
     pass
 
-
-class WordAppearsToBeParabolic(DrillGeodesicError):
-    def __init__(self, word, trace):
-        self.word = word
-        self.trace = trace
-        super().__init__(
-            "Attempting to drill a geodesic corresponding to a matrix "
-            "that could be parabolic. "
-            "Word: %s, trace: %r." % (word, trace))
-
-
 class GeodesicSystemNotSimpleError(DrillGeodesicError):
     def __init__(self, maximal_tube_radius):
         self.maximal_tube_radius = maximal_tube_radius
@@ -21,26 +10,13 @@ class GeodesicSystemNotSimpleError(DrillGeodesicError):
             "The maximal tube radius about the given system of geodesics "
             "was estimated to be: %r." % maximal_tube_radius)
 
-
-class GeodesicCloseToCoreCurve(DrillGeodesicError):
-    def __init__(self):
-        super().__init__(
-            "The given geodesic is very close to a core curve and might "
-            "intersect it.")
-
-
-class UnfinishedGraphTraceGeodesicError(DrillGeodesicError):
-    def __init__(self, steps):
-        self.steps = steps
+class GeodesicMultipleOfCoreCurve(DrillGeodesicError):
+    def __init__(self, word, multiplicity):
+        self.word = word
+        self.multiplicity = multiplicity
         super().__init__(
-            "The line fixed by the given word could not be moved (by "
-            "Decktransformations) to intersect the fundamental domain after "
-            "%d steps. "
-            "This is probably due to a pathology, e.g., a bad conjugate "
-            "was picked and the line is very far away from the fundamental "
-            "domain or the given geodesic is very close to a core curve of "
-            "a filled cusp." % steps)
-
+            "The geodesic %s is a %d-fold multiple of a core curve." % (
+                word, multiplicity))
 
 class UnfinishedTraceGeodesicError(DrillGeodesicError):
     def __init__(self, steps):
@@ -51,15 +27,6 @@ class UnfinishedTraceGeodesicError(DrillGeodesicError):
             "e.g., the geodesic is very close to a core curve of "
             "filled cusp." % steps)
 
-class GeodesicStartingPiecesCrossSameFaceError(DrillGeodesicError):
-    def __init__(self):
-        super().__init__(
-            "The first and last piece of the geodesic do not cross distinct "
-            "faces. This can happen if the amount the start point was "
-            "perturbed too much. Unfortunately, reducing this amount has "
-            "not been implemented yet. If you run into this case, please "
-            "report it giving the manifold and geodesic it occurred with.")
-
 class GeodesicHittingOneSkeletonError(DrillGeodesicError):
     """
     Base class for exceptions caused by the geodesic hitting the
@@ -69,7 +36,7 @@ class GeodesicHittingOneSkeletonError(DrillGeodesicError):
 
 class GeodesicStartPointOnTwoSkeletonError(GeodesicHittingOneSkeletonError):
     """
-    Raised when the start point given to GeodesicInfo appears not to be in the
+    Raised when the start point given to GeodesicStartPointInfo appears not to be in the
     interior of a tetrahedron.
     """