snappy 3.0.3__cp38-cp38-macosx_11_0_arm64.whl → 3.2__cp38-cp38-macosx_11_0_arm64.whl

snappy/snap/fundamental_polyhedron.py

@@ -4,38 +4,26 @@ from . import t3mlite as t3m
 from .t3mlite import ZeroSubsimplices, simplex
 from .t3mlite import Corner, Perm4
 from .t3mlite import V0, V1, V2, V3
+from ..math_basics import prod
 from functools import reduce
 
 __all__ = ['FundamentalPolyhedronEngine']
 
 from ..sage_helper import _within_sage
 if _within_sage:
-    from sage.all import sqrt, matrix, prod
+    from ..sage_helper import matrix
 else:
-    import math
-    def sqrt(x):
-        if hasattr(x, 'sqrt'):
-            return x.sqrt()
-        return math.sqrt(x)
-
-    def prod(L, initial=None):
-        if initial:
-            return reduce(lambda x, y : x*y, L, initial)
-        elif L:
-            return reduce(lambda x, y : x*y, L)
-        else:
-            return 1
-
     from .utilities import Matrix2x2 as matrix
 
 _VerticesInFace = {
     F: [V for V in simplex.ZeroSubsimplices if t3m.is_subset(V, F)]
     for F in simplex.TwoSubsimplices }
 
+
 class FundamentalPolyhedronEngine(McomplexEngine):
     @staticmethod
     def from_manifold_and_shapes(
-        manifold, shapes, normalize_matrices = False, match_kernel = True):
+        manifold, shapes, normalize_matrices=False, match_kernel=True):
         """
         Given a SnapPy.Manifold and shapes (which can be numbers or intervals),
         create a t3mlite.Mcomplex for the fundamental polyhedron that the
@@ -67,16 +55,16 @@ class FundamentalPolyhedronEngine(McomplexEngine):
         The above code adds the given shapes to each edge (here 01) of each
         tetrahedron::
 
-        >>> from snappy.snap.t3mlite import simplex
-        >>> F.mcomplex.Tetrahedra[0].ShapeParameters[simplex.E01] # doctest: +NUMERIC6
-        0.500000000000000 + 0.866025403784438*I
+            >>> from snappy.snap.t3mlite import simplex
+            >>> F.mcomplex.Tetrahedra[0].ShapeParameters[simplex.E01] # doctest: +NUMERIC6
+            0.500000000000000 + 0.866025403784438*I
 
         And annotates each face (here 1) of each tetrahedron with the
         corresponding generator (here, the inverse of the second generator)
         or 0 if the face is internal to the fundamental polyhedron::
 
-        >>> F.mcomplex.Tetrahedra[0].GeneratorsInfo[simplex.F1]
-        -2
+            >>> F.mcomplex.Tetrahedra[0].GeneratorsInfo[simplex.F1]
+            -2
 
         This information is also available in a dict keyed by generator.
         For each generator, it gives a list of the corresponding face pairing
@@ -88,29 +76,29 @@ class FundamentalPolyhedronEngine(McomplexEngine):
         pairing of face 2 of tet 1 to face 1 of tet0 such that face 2 is
         taken to face 1 by the permutation (3, 0, 1, 2)::
 
-        >>> F.mcomplex.Generators[2]
-        [((<F2 of tet1>, <F1 of tet0>), (3, 0, 1, 2))]
+            >>> F.mcomplex.Generators[2]
+            [((<F2 of tet1>, <F1 of tet0>), (3, 0, 1, 2))]
 
         The four vertices of tetrahedron 1::
 
-        >>> for v in simplex.ZeroSubsimplices: # doctest: +NUMERIC6
-        ...     F.mcomplex.Tetrahedra[1].Class[v].IdealPoint
-        'Infinity'
-        0.000000000000000
-        0.866025403784439 - 0.500000000000000*I
-        0.866025403784439 + 0.500000000000000*I
+            >>> for v in simplex.ZeroSubsimplices: # doctest: +NUMERIC6
+            ...     F.mcomplex.Tetrahedra[1].Class[v].IdealPoint
+            'Infinity'
+            0.000000000000000
+            0.866025403784439 - 0.500000000000000*I
+            0.866025403784439 + 0.500000000000000*I
 
         The matrix for generator 1 (of the unsimplified presentation)::
 
-        >>> F.mcomplex.GeneratorMatrices[1] # doctest: +NUMERIC6 +ELLIPSIS
-        [   -0.577350269189626 - 1.00000000000000*I    0.500000000000000 + 0.288675134594813*I...]
-        [  -0.500000000000000 - 0.288675134594813*I 0.577350269189626 + 2.22044604925031e-16*I...]
+            >>> F.mcomplex.GeneratorMatrices[1] # doctest: +NUMERIC6 +ELLIPSIS
+            [   -0.577350269189626 - 1.00000000000000*I    0.500000000000000 + 0.288675134594813*I...]
+            [  -0.500000000000000 - 0.288675134594813*I 0.577350269189626 + 2.22044604925031e-16*I...]
 
         Get the cusp that a vertex of the fundamental polyhedron corresponds
         to::
 
-        >>> F.mcomplex.Tetrahedra[1].Class[simplex.V0].SubsimplexIndexInManifold
-        0
+            >>> F.mcomplex.Tetrahedra[1].Class[simplex.V0].SubsimplexIndexInManifold
+            0
 
         """
 
@@ -121,7 +109,7 @@ class FundamentalPolyhedronEngine(McomplexEngine):
 
         t.add_shapes(shapes)
         t.choose_and_transfer_generators(
-            compute_corners = True, centroid_at_origin = False)
+            compute_corners=True, centroid_at_origin=False)
 
         f.unglue()
 
@@ -132,7 +120,7 @@ class FundamentalPolyhedronEngine(McomplexEngine):
 
         f.visit_tetrahedra_to_compute_vertices(
             m.ChooseGenInitialTet, init_verts)
-        f.compute_matrices(normalize_matrices = normalize_matrices)
+        f.compute_matrices(normalize_matrices=normalize_matrices)
 
         return f
 
@@ -240,11 +228,11 @@ class FundamentalPolyhedronEngine(McomplexEngine):
         tet = self.mcomplex.ChooseGenInitialTet
 
         z = tet.ShapeParameters[simplex.E01]
-        NumericField = z.parent()
+        CF = z.parent()
 
         return { simplex.V0 : Infinity,
-                 simplex.V1 : NumericField(0),
-                 simplex.V2 : NumericField(1),
+                 simplex.V1 : CF(0),
+                 simplex.V2 : CF(1),
                  simplex.V3 : z }
 
     def init_vertices_kernel(self):
@@ -253,38 +241,51 @@ class FundamentalPolyhedronEngine(McomplexEngine):
         made by the SnapPea kernel.
         """
 
+        # Note that initial_tetrahedron in choose_generators.c picks
+        # the initial tetrahedron and best edge in a purely combinatorial way -
+        # and doesn't use shapes to assign 0 and Infinity to the ends of
+        # the edges.
+        #
+        # Hence, the code below can't be tricked into picking a different
+        # permutation by setting the unverified shapes stored in the
+        # kernel Triangulation (to some non-sensical values). It would fail
+        # instead.
+
         tet = self.mcomplex.ChooseGenInitialTet
 
+        candidates = []
+
         for perm in Perm4.A4():
             z = tet.ShapeParameters[perm.image(simplex.E01)]
-            NumericField = z.parent()
-            one = NumericField(1)
-            minus_one = NumericField(-1)
-            sqrt_z = sqrt(z)
-            sqrt_z_inv = one / sqrt_z
-
-            for sign in [one, minus_one]:
-                candidates = {
-                    perm.image(simplex.V0) : NumericField(0),
-                    perm.image(simplex.V1) : Infinity,
-                    perm.image(simplex.V2) : sign * sqrt_z,
-                    perm.image(simplex.V3) : sign * sqrt_z_inv
-                }
-
-                if _are_vertices_close_to_kernel(
-                            candidates, tet.SnapPeaIdealVertices):
-                    return candidates
+            # Complex field
+            CF = z.parent()
+            sqrt_z = z.sqrt()
+            sqrt_z_inv = CF(1) / sqrt_z
+
+            candidate = {
+                perm.image(simplex.V0) : Infinity,
+                perm.image(simplex.V1) : CF(0),
+                perm.image(simplex.V2) : sqrt_z_inv,
+                perm.image(simplex.V3) : sqrt_z
+            }
+
+            if _are_vertices_close_to_kernel(
+                    candidate, tet.SnapPeaIdealVertices):
+                candidates.append(candidate)
+
+        if len(candidates) == 1:
+            return candidates[0]
 
         raise Exception(
             "Could not match vertices to vertices from SnapPea kernel")
 
-    def compute_matrices(self, normalize_matrices = False):
+    def compute_matrices(self, normalize_matrices=False):
         """
         Assuming positions were assigned to the vertices, adds
         GeneratorMatrices to the Mcomplex which assigns a matrix to each
         generator.
 
-        Compute generator matrices::
+        Compute generator matrices:
 
         >>> M = Manifold("s776")
         >>> F = FundamentalPolyhedronEngine.from_manifold_and_shapes(
@@ -292,7 +293,7 @@ class FundamentalPolyhedronEngine(McomplexEngine):
         >>> generatorMatrices = F.mcomplex.GeneratorMatrices
 
         Given a letter such as 'a' or 'A', return matrix for corresponding
-        generator::
+        generator:
 
         >>> def letterToMatrix(l, generatorMatrices):
         ...     g = ord(l.lower()) - ord('a') + 1
@@ -317,7 +318,11 @@ class FundamentalPolyhedronEngine(McomplexEngine):
 
         """
 
-        self.mcomplex.GeneratorMatrices = { }
+        z = self.mcomplex.Tetrahedra[0].ShapeParameters[simplex.E01]
+        CF = z.parent()
+
+        self.mcomplex.GeneratorMatrices = { 0 : matrix([[CF(1), CF(0)],
+                                                        [CF(0), CF(1)]]) }
 
         for g, pairings in self.mcomplex.Generators.items():
             # We compute the matrix for the generator and its inverse at the
@@ -325,7 +330,7 @@ class FundamentalPolyhedronEngine(McomplexEngine):
             if g > 0:
                 m = _compute_pairing_matrix(pairings[0])
                 if normalize_matrices:
-                    m = m / sqrt(m.det())
+                    m = m / m.det().sqrt()
                 self.mcomplex.GeneratorMatrices[ g] = m
                 self.mcomplex.GeneratorMatrices[-g] = _adjoint2(m)
 
@@ -337,7 +342,7 @@ class FundamentalPolyhedronEngine(McomplexEngine):
 
         The GeneratorMatrices computed here are for the face-pairing
         presentation with respect to the fundamental polyhedron.
-        That presentation can be simplfied by M.fundamental_group(...)
+        That presentation can be simplified by M.fundamental_group(...)
         and this function will compute the matrices for the simplified
         presentation from the GeneratorMatrices.
 
@@ -360,6 +365,7 @@ class FundamentalPolyhedronEngine(McomplexEngine):
         else:
             return result
 
+
 def _diff_to_kernel(value, snappeaValue):
     """
     The SnapPea kernel will always give us a number, but we might deal
@@ -367,18 +373,21 @@ def _diff_to_kernel(value, snappeaValue):
 
     Cast to our numeric type so that we can compare.
     """
-    NumericField = value.parent()
-    return value - NumericField(snappeaValue)
+    CF = value.parent()
+    return value - CF(snappeaValue)
+
+
+def _is_number_close_to_kernel(value, snappeaValue, error=10**-6):
+    CF = value.parent()
+    return abs(_diff_to_kernel(value, snappeaValue)) < CF(error)
 
-def _is_number_close_to_kernel(value, snappeaValue, error = 10**-6):
-    NumericField = value.parent()
-    return abs(_diff_to_kernel(value, snappeaValue)) < NumericField(error)
 
 def _is_vertex_close_to_kernel(vertex, snappeaVertex):
     if vertex == Infinity or snappeaVertex == Infinity:
         return vertex == snappeaVertex
     return _is_number_close_to_kernel(vertex, snappeaVertex)
 
+
 def _are_vertices_close_to_kernel(verts, snappeaVerts):
     for key, vert in verts.items():
         snappeaVert = snappeaVerts[key]
@@ -386,11 +395,13 @@ def _are_vertices_close_to_kernel(verts, snappeaVerts):
             return False
     return True
 
+
 _RemainingFace = {  (V0, V1): V3, (V0, V2): V1, (V0, V3): V2,
                     (V1, V0): V2, (V1, V2): V3, (V1, V3): V0,
                     (V2, V0): V3, (V2, V1): V0, (V2, V3): V1,
                     (V3, V0): V1, (V3, V1): V2, (V3, V2): V0}
 
+
 def _compute_fourth_corner(T):
     v = 4 * [ None ]
     missing_corners = [V for V in ZeroSubsimplices if T.Class[V].IdealPoint is None]
@@ -406,7 +417,7 @@ def _compute_fourth_corner(T):
 
     cross_ratio = T.ShapeParameters[ v[0] | v[1] ]
     if z[0] == Infinity:
-        z[3] = z[1] + cross_ratio * (z[2]  - z[1])
+        z[3] = z[1] + cross_ratio * (z[2] - z[1])
     else:
         diff20 = z[2] - z[0]
         diff21 = z[2] - z[1]
@@ -419,6 +430,7 @@ def _compute_fourth_corner(T):
 
     T.Class[missing_corner].IdealPoint = z[3]
 
+
 def _normalize_points(a, b):
     """
     Reduce the number of cases involving infinity that we need to
@@ -444,6 +456,7 @@ def _normalize_points(a, b):
     a.reverse(), b.reverse()
     return a, b
 
+
 def _matrix_taking_triple_to_triple(a, b):
     """
     To quote Jeff:
@@ -458,7 +471,6 @@ def _matrix_taking_triple_to_triple(a, b):
 
         k = [(b2-b0)/(b2-b1)] * [(a2-a1)/(a2-a0)]
     """
-
     # Let's make it so that a[0], a[1], and b[0] are never infinite
 
     (a0, a1, a2), (b0, b1, b2) = _normalize_points(a,b)
@@ -468,23 +480,22 @@ def _matrix_taking_triple_to_triple(a, b):
     if b1 == Infinity:
         kb, b1kb = 0, -(b2 - b0)
     else:
-        kb =  (b2 - b0)/(b2 - b1) if b2 != Infinity else 1
+        kb = (b2 - b0)/(b2 - b1) if b2 != Infinity else 1
         b1kb = b1 * kb
 
-    k = kb*ka
+    k = kb * ka
 
-    A = matrix( [  ( b1kb * ka - b0,   b0*a1 - a0*b1kb*ka),
-                   (k - 1, a1 - k*a0)])
+    return matrix([(b1kb * ka - b0, b0 * a1 - a0 * b1kb * ka),
+                   (k - 1, a1 - k * a0)])
 
-    return A
 
 def _adjoint2(m):
     """
     Sage matrix.adjoint() produces an unnecessary large interval for
     ComplexIntervalField entries.
     """
+    return matrix([[m[1, 1], -m[0, 1]], [-m[1, 0], m[0, 0]]])
 
-    return matrix([[m[1,1], -m[0, 1]], [-m[1, 0], m[0, 0]]])
 
 def _perform_word_moves(matrices, G):
     mats = [ None ] + matrices
@@ -500,9 +511,9 @@ def _perform_word_moves(matrices, G):
             if a == b:  # generator removed
                 mats[a] = mats[-1]
                 mats = mats[:-1]
-            elif a == -b: # invert generator
+            elif a == -b:  # invert generator
                 mats[a] = _adjoint2(mats[a])
-            else: #handle slide
+            else:  # handle slide
                 A, B = mats[abs(a)], mats[abs(b)]
                 if a*b < 0:
                     B = _adjoint2(B)
@@ -510,14 +521,16 @@ def _perform_word_moves(matrices, G):
 
     return mats[1 : G.num_generators() + 1]
 
+
 def _matrix_L1_distance_to_kernel(m, snappeaM):
     return sum([ abs(_diff_to_kernel(m[i,j], snappeaM[i,j]))
                  for i in range(2)
                  for j in range(2)])
 
+
 def _negate_matrix_to_match_kernel(m, snappeaM):
-    diff_plus  = _matrix_L1_distance_to_kernel(m,  snappeaM)
-    
+    diff_plus = _matrix_L1_distance_to_kernel(m, snappeaM)
+
     diff_minus = _matrix_L1_distance_to_kernel(m, -snappeaM)
 
     # Note that from an interval perspective, (not diff_plus < diff_minus)
@@ -527,10 +540,11 @@ def _negate_matrix_to_match_kernel(m, snappeaM):
     # choice that the SnapPea kernel made.
 
     if diff_plus < diff_minus:
-        return  m
+        return m
     else:
         return -m
 
+
 def _negate_matrices_to_match_kernel(matrices, G):
     """
     Normalize things so the signs of the matices match SnapPy's default
@@ -540,16 +554,16 @@ def _negate_matrices_to_match_kernel(matrices, G):
     return [ _negate_matrix_to_match_kernel(m, matrix(G.SL2C(g)))
              for m, g in zip(matrices, G.generators()) ]
 
+
 def _compute_pairing_matrix(pairing):
     (inCorner, outCorner), perm = pairing
-    
-    inTriple  = []
+
+    inTriple = []
     outTriple = []
-    
+
     for v in simplex.ZeroSubsimplices:
         if simplex.is_subset(v, inCorner.Subsimplex):
             inTriple.append(inCorner.Tetrahedron.Class[v].IdealPoint)
             outTriple.append(outCorner.Tetrahedron.Class[perm.image(v)].IdealPoint)
-            
-    return _matrix_taking_triple_to_triple(outTriple, inTriple)
 
+    return _matrix_taking_triple_to_triple(outTriple, inTriple)

snappy/snap/generators.py

@@ -2,19 +2,21 @@
 This has been moved to FundamentalPolyhedronEngine.
 Only the testing code was left here.
 
-Replicating how SnapPea finds the matices of the geometric generators,
-so that this can replicated using e.g. extended precision.  
+Replicating how SnapPea finds the matrices of the geometric generators,
+so that this can replicated using e.g. extended precision.
 """
 
 from .fundamental_polyhedron import *
 from . import t3mlite as t3m
 from .t3mlite import ZeroSubsimplices
 
+
 # Testing code
 
 def matrix_norm(A):
     return max(map(abs, A.list()))
 
+
 def check_example(M, shapes=None):
     e = fromManifoldAndShapes(M, shapes)
 
@@ -30,12 +32,8 @@ def check_example(M, shapes=None):
     mats = compute_matrices(MM)
     for i in range(1, G.num_generators() + 1):
         A = mats[i]
-        B = G.SL2C(G.generators()[i-1])
-        error = min(matrix_norm(A-B), matrix_norm(A+B))
+        B = G.SL2C(G.generators()[i - 1])
+        error = min(matrix_norm(A - B), matrix_norm(A + B))
         max_error = max(max_error, error)
 
     return max_error
-
-
-
-

snappy/snap/interval_reps.py

@@ -4,33 +4,45 @@ specifically elements of Sage's ComplexIntervalField.  Also contains
 some utility functions for dealing with such representations.
 """
 
-from . import polished_reps
+from .polished_reps import ManifoldGroup
 from .fundamental_polyhedron import *
 
+# Most of the below small functions are not used in SnapPy proper, but
+# published code (https://doi.org/10.7910/DVN/LCYXPO) depends on them,
+# so they should not be removed.
+
+
 def matrix_difference_norm(A, B):
     B = B.change_ring(A.base_ring())
     return max([abs(a - b) for a,b in zip(A.list(), B.list())])
 
+
 def diameter(A):
     return max(x.diameter() for x in A.list())
 
+
 def contains_zero(A):
     return all(x.contains_zero() for x in A.list())
 
+
 def contains_one(A):
     return contains_zero(A - 1)
 
+
 def contains_plus_minus_one(A):
     return contains_one(A) or contains_one(-A)
 
+
 def could_be_equal_numbers(x, y):
     return (x - y).contains_zero()
 
+
 def could_be_equal(A, B):
     return contains_zero(A - B)
 
+
 def holonomy_from_shape_intervals(manifold, shape_intervals,
-                                  fundamental_group_args = [], lift_to_SL2 = True):
+                                  fundamental_group_args=[], lift_to_SL2=True):
     """
     Returns the representation
 
@@ -60,10 +72,10 @@ def holonomy_from_shape_intervals(manifold, shape_intervals,
     M = manifold
     G = M.fundamental_group(*fundamental_group_args)
     f = FundamentalPolyhedronEngine.from_manifold_and_shapes(
-        M, shape_intervals, normalize_matrices = True)
-    mats = f.matrices_for_presentation(G, match_kernel = True)
-    PG = polished_reps.ManifoldGroup(G.generators(), G.relators(),
-                                     G.peripheral_curves(), mats)
+        M, shape_intervals, normalize_matrices=True)
+    mats = f.matrices_for_presentation(G, match_kernel=True)
+    PG = ManifoldGroup(G.generators(), G.relators(),
+                       G.peripheral_curves(), mats)
     if lift_to_SL2:
         PG.lift_to_SL2C()
     return PG

snappy/snap/kernel_structures.py

@@ -6,6 +6,7 @@ Infinity = "Infinity"
 __all__ = ['Infinity',
            'TransferKernelStructuresEngine']
 
+
 def _clean_ideal_vertices(vertices):
     """
     The SnapPea kernel gives us a large number for infinity.
@@ -13,9 +14,10 @@ def _clean_ideal_vertices(vertices):
     """
     return [ x if abs(x) < 10.0E20 else Infinity for x in vertices]
 
+
 class TransferKernelStructuresEngine(McomplexEngine):
     def __init__(self, mcomplex, snappyTriangulation):
-        super(TransferKernelStructuresEngine, self).__init__(mcomplex)
+        super().__init__(mcomplex)
         self.snappyTriangulation = snappyTriangulation
 
     def add_shapes(self, shapes):
@@ -28,7 +30,7 @@ class TransferKernelStructuresEngine(McomplexEngine):
         """
 
         for tet, z in zip(self.mcomplex.Tetrahedra, shapes):
-            zp  = 1 / (1 - z)
+            zp = 1 / (1 - z)
             zpp = (z - 1) / z
             tet.ShapeParameters = {
                 simplex.E01: z,
@@ -111,7 +113,7 @@ class TransferKernelStructuresEngine(McomplexEngine):
                                           cusp_indices[i]):
                 tet.Class[vertex].Index = cusp_index
 
-        self.mcomplex.Vertices.sort(key = lambda vertex : vertex.Index)
+        self.mcomplex.Vertices.sort(key=lambda vertex: vertex.Index)
 
         for index, vertex in enumerate(self.mcomplex.Vertices):
             if not index == vertex.Index:
@@ -121,3 +123,6 @@ class TransferKernelStructuresEngine(McomplexEngine):
         self.reindex_cusps_and_add_peripheral_curves(
             self.snappyTriangulation._get_cusp_indices_and_peripheral_curve_data())
 
+        for cusp, cusp_info in zip(self.mcomplex.Vertices,
+                                   self.snappyTriangulation.cusp_info()):
+            cusp.is_complete = cusp_info['complete?']

snappy/snap/mcomplex_base.py

@@ -1,5 +1,5 @@
 
-class McomplexEngine(object):
+class McomplexEngine():
     """
     A base for classes that modify or add extra structure to a t3mlite.Mcomplex.
     """
@@ -15,5 +15,4 @@ class McomplexEngine(object):
         an engine and perform certain modifications, see, e.g.,
         FundamentalPolyhedronEngine.from_manifold_and_shapes.
         """
-
         self.mcomplex = mcomplex