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

snappy/snap/slice_obs_HKL.py

@@ -45,10 +45,8 @@ correct.
 
 from ..sage_helper import _within_sage, sage_method
 if _within_sage:
-    from sage.all import (ZZ, PolynomialRing, LaurentPolynomialRing,
-                          GF, QQ, CyclotomicField, vector, matrix,
-                          identity_matrix, block_matrix, diagonal_matrix,
-                          MatrixSpace, ChainComplex, prime_range)
+    from ..sage_helper import ZZ, PolynomialRing, vector, matrix, identity_matrix, MatrixSpace, block_matrix, prime_range, is_prime
+    from ..sage_helper import LaurentPolynomialRing, GF, CyclotomicField, ChainComplex
 
     from .nsagetools import (MapToFreeAbelianization, compute_torsion,
                              fox_derivative_with_involution,
@@ -81,10 +79,10 @@ class MatrixRepresentation():
         if isinstance(matrices, dict):
             images = matrices
             all_gens = list(generators) + [g.swapcase() for g in generators]
-            assert set(matrices.keys()) == set(all_gens)
+            assert set(matrices) == set(all_gens)
         else:
             assert len(generators) == len(matrices)
-            images = dict()
+            images = {}
             for g, m in zip(generators, matrices):
                 images[g] = m
                 images[g.swapcase()] = image_ring(m.inverse())
@@ -185,7 +183,6 @@ def poly_to_rep(f):
     left action of x on F[x]/(f).
     """
     assert f.is_monic()
-    x = f.parent().gen()
     d = f.degree()
     last_column = [-f[e] for e in range(d)]
     I = identity_matrix(d)
@@ -348,7 +345,7 @@ def induced_rep_from_twisted_cocycle(p, rho, chi, cocycle):
     t = R.gen()
     MatSp = MatrixSpace(R, p)
     gens = rho.generators
-    images = dict()
+    images = {}
     for s, g in enumerate(gens):
         v = vector(cocycle[s*n:(s+1)*n])
         e = rho.epsilon(g)[0]
@@ -548,6 +545,8 @@ def slicing_is_obstructed(knot_exterior, p, q):
        sage: slicing_is_obstructed(M, 3, 7)
        True
     """
+    p, q = ZZ(p), ZZ(q)
+    assert is_prime(p) and is_prime(q) and q > 2
     reps = list(reps_appearing(knot_exterior, p, q))
     if len(reps) == 0:
         return False
@@ -564,13 +563,14 @@ def slicing_is_obstructed(knot_exterior, p, q):
     return True
 
 
-def expand_prime_spec(spec):
+def expand_prime_spec(spec, min_prime=2):
     if spec in ZZ:
         a, b = 0, spec
     else:
         if len(spec) != 2:
             raise ValueError(f'Spec {spec} does not specify a range')
         a, b = spec
+    a = max(a, min_prime)
     return prime_range(a, b + 1)
 
 
@@ -596,7 +596,6 @@ def slice_obstruction_HKL(self, primes_spec,
        sage: spec = [(10, [0, 20]), (20, [0, 10])]
        sage: M.slice_obstruction_HKL(spec, verbose=True)
           Looking at (2, 3) ...
-          Looking at (3, 2) ...
           Looking at (3, 7) ...
        (3, 7)
 
@@ -605,7 +604,6 @@ def slice_obstruction_HKL(self, primes_spec,
 
        sage: spec = [([3, 10], 10)]
        sage: M.slice_obstruction_HKL(spec, verbose=True)
-          Looking at (3, 2) ...
           Looking at (3, 7) ...
        (3, 7)
 
@@ -639,13 +637,17 @@ def slice_obstruction_HKL(self, primes_spec,
     if len(primes_spec) == 2:
         p, q = primes_spec
         if p in ZZ and q in ZZ:
+            if q == 2:
+                raise ValueError('Must have q > 2 when looking at H_1(cover; F_q)')
+            if not (is_prime(p) and is_prime(q)):
+                raise ValueError('Both p and q must be prime')
             if slicing_is_obstructed(M, p, q):
                 return (p, q)
             else:
                 return None
 
     # Main case
-    primes_spec = [(expand_prime_spec(a), expand_prime_spec(b))
+    primes_spec = [(expand_prime_spec(a), expand_prime_spec(b, min_prime=3))
                    for a, b in primes_spec]
     for ps, qs in primes_spec:
         for p in ps:
@@ -654,8 +656,8 @@ def slice_obstruction_HKL(self, primes_spec,
                 if d % q == 0:
                     if verbose:
                         print('   Looking at', (p, q), '...')
-                        if slicing_is_obstructed(M, p, q):
-                            return (p, q)
+                    if slicing_is_obstructed(M, p, q):
+                        return (p, q)
 
 
 if __name__ == '__main__':

snappy/snap/t3mlite/arrow.py

@@ -37,7 +37,7 @@ from .perm4 import Perm4, inv
 
 # For speed, we create a lookup table for all possible gluing permutations
 
-_arrow_gluing_dict = dict()
+_arrow_gluing_dict = {}
 for edge0, face0 in EdgeFacePairs:
     for edge1, face1 in EdgeFacePairs:
         perm = Perm4({FaceIndex[face0]:FaceIndex[flip_face[edge1, face1]],
@@ -48,7 +48,7 @@ for edge0, face0 in EdgeFacePairs:
 
 # Another table to speed Arrow.opposite
 
-_arrow_opposite_dict = dict()
+_arrow_opposite_dict = {}
 for edge, face in EdgeFacePairs:
     tail = comp(face)
     head = face & comp(edge)
@@ -59,7 +59,7 @@ for edge, face in EdgeFacePairs:
 
 # Another table to speed Arrow.next
 
-_arrow_next_dict = dict()
+_arrow_next_dict = {}
 for edge, face in EdgeFacePairs:
     for perm in Perm4.S4():
         new_edge = perm.image(edge)

snappy/snap/t3mlite/edge.py

@@ -16,7 +16,7 @@ import sys
 # other_arrow = arrow.copy().opposite()
 # tail, head = other_arrow.tail(), other_arrow.head()
 
-_edge_add_corner_dict = dict()
+_edge_add_corner_dict = {}
 for edge, face in EdgeFacePairs:
     other_arrow = Arrow(edge, face, None).opposite()
     _edge_add_corner_dict[edge, face] = other_arrow.tail(), other_arrow.head()
@@ -35,7 +35,7 @@ class Edge:
         self.Vertices = []          # pairs: (initial Vertex, terminal Vertex)
         self.LeftBdryArrow = None   # Arrows representing the two boundary faces,
         self.RightBdryArrow = None  # if this is a boundary edge.
-        self._edge_orient_cache = dict()
+        self._edge_orient_cache = {}
 
     def __repr__(self):
         if self.Index > -1:
@@ -155,7 +155,7 @@ class Edge:
         tet, perm = self._first_embedding()
         for i in range(order):
             yield tet, perm
-            face = perm.image(1 | 2 | 8)
+            face = perm.image(F2)
             tet, perm = (
                 tet.Neighbor[face], tet.Gluing[face] * perm * Perm4( (0,1,3,2) ))
 

snappy/snap/t3mlite/homology.py

@@ -6,7 +6,7 @@ def boundary_three(manifold):
     F, T = len(manifold.Faces), len(manifold.Tetrahedra)
     ans = Matrix(F, T)
     for F in manifold.Faces:
-        t0, t1 = [C.Tetrahedron.Index for C in F.Corners]
+        t0, t1 = (C.Tetrahedron.Index for C in F.Corners)
         ans[F.Index, t0] += 1
         ans[F.Index, t1] += -1
     return ans
@@ -33,7 +33,7 @@ def boundary_one(manifold):
     V, E = len(manifold.Vertices), len(manifold.Edges)
     ans = Matrix(V, E)
     for e in manifold.Edges:
-        v_init, v_term = [v.Index for v in e.Vertices]
+        v_init, v_term = (v.Index for v in e.Vertices)
         ans[v_term, e.Index] += 1
         ans[v_init, e.Index] += -1
     return ans

snappy/snap/t3mlite/mcomplex.py

@@ -263,7 +263,7 @@ class Mcomplex:
             out.write("\nEdges:\n")
             for edge in self.Edges:
                 edge.info(out)
-        except IOError:
+        except OSError:
             pass
 
     def build_edge_classes(self):
@@ -483,7 +483,7 @@ class Mcomplex:
                 out.write("-------------------------------------\n\n")
                 surface.info(self, out)
                 out.write('\n')
-        except IOError:
+        except OSError:
             pass
 
     def almost_normal_surface_info(self, out=sys.stdout):
@@ -492,7 +492,7 @@ class Mcomplex:
                 out.write("-------------------------------------\n\n")
                 surface.info(self, out)
                 out.write('\n')
-        except IOError:
+        except OSError:
             pass
 
     # Simplification Moves

snappy/snap/t3mlite/simplex.py

@@ -162,6 +162,18 @@ VerticesOfFaceCounterclockwise = {
     F3: (V1, V2, V0)
 }
 
+# Dimension of a subsimplex
+def dimension(x):
+    if x in ZeroSubsimplices:
+        return 0
+    if x in OneSubsimplices:
+        return 1
+    if x in TwoSubsimplices:
+        return 2
+    if x == T:
+        return 3
+    raise Exception("%r is not a subsimplex" % x)
+
 # Decide if the bitmap x represents a subset of the bitmap y
 
 

snappy/snap/t3mlite/spun.py

@@ -6,19 +6,18 @@ of it (though depending very much on snappy), except for borrowing
 some linear algebra code.
 """
 
-import snappy
 import FXrays
-if snappy._within_sage:
-    from sage.all import gcd
-    from sage.all import vector as Vector
-    from sage.all import matrix as Matrix
+
+from ...sage_helper import _within_sage
+if _within_sage:
+    from ...sage_helper import vector as Vector, matrix as Matrix, gcd
 else:
     from snappy.snap.t3mlite.linalg import Vector, Matrix, gcd
 
 
 def weak_normalize_slope(slope):
     """For a tuple (a, b), scale it so that gcd(a,b)=1"""
-    a, b = [int(s) for s in slope]
+    a, b = (int(s) for s in slope)
     if a == b == 0:
         return (0, 0)
     g = gcd(a,b)
@@ -54,7 +53,8 @@ def normalize_slope(slope):
 def shift_matrix(n):
     """
     The edge shifts corresponding to each of three quad types, see Figure
-    2.1 and 2.2 of `[DG] <http://arxiv.org/abs/1102.4588>`_
+    2.1 and 2.2 of
+    `Dunfield and Garoufalidis '12 <http://arxiv.org/abs/1102.4588>`_.
     """
     shifts = Matrix(3*n, 3*n)
     for i in range(0, 3*n, 3):
@@ -92,14 +92,14 @@ class SpunSurface:
     A spun normal surface in an ideal triangulation, as introduced by
     Thurston.
 
-    For an quick sketch of this theory see `[DG]
+    For an quick sketch of this theory see `Dunfield and Garoufalidis '12
     <http://arxiv.org/abs/1102.4588>`_ and for more details see
-    `[Tillmann] <http://arxiv.org/abs/math/0406271>`_.
+    `Tillmann '08 <http://arxiv.org/abs/math/0406271>`_.
 
     The quad conventions are (Q02, Q03, Q01) corresponding to
     z -> 0, z' -> 0, and z'' -> 0 respectively, as per Figure 3.1 of
-    `[DG] <http://arxiv.org/abs/1102.4588>`_.  The quad types
-    are numbered 0, 1, 2; the "None" quad type means a
+    `Dunfield and Garoufalidis '12 <http://arxiv.org/abs/1102.4588>`_.
+    The quad types are numbered 0, 1, 2; the "None" quad type means a
     tetrahedron contains no quads at all.
     """
     def __init__(self, manifold, quad_vector=None, quad_types=None, index=None):
@@ -245,9 +245,9 @@ def normal_boundary_slopes(self, subset='all', algorithm='FXrays'):
 
     If the ``subset`` flag is set to ``'kabaya'``, then it only
     returns boundary slopes associated to vertex surfaces with a quad
-    in every tetrahedron; by Theorem 1.1. of `[DG]
-    <http://arxiv.org/abs/1102.4588>`_ these are all strict boundary
-    slopes.
+    in every tetrahedron; by Theorem 1.1. of
+    `Dunfield and Garoufalidis '12 <http://arxiv.org/abs/1102.4588>`_
+    these are all strict boundary slopes.
 
     >>> N = Manifold('m113')
     >>> N.normal_boundary_slopes()
@@ -285,12 +285,13 @@ def normal_boundary_slopes(self, subset='all', algorithm='FXrays'):
         if subset != 'all':
             raise ValueError("Subset must be one of 'all', 'kabaya', or 'brasile'")
 
-    slopes = set([normalize_slope(S.boundary_slopes()) for S in surfaces])
-    slopes.discard( (0, 0) )
+    slopes = {normalize_slope(S.boundary_slopes()) for S in surfaces}
+    slopes.discard((0, 0))
     return sorted(slopes)
 
 
 if __name__ == "__main__":
     import doctest
-    names = {'Manifold':snappy.Manifold}
+    import snappy
+    names = {'Manifold': snappy.Manifold}
     doctest.testmod(extraglobs=names)

snappy/snap/t3mlite/test_vs_regina.py

@@ -6,8 +6,8 @@ import snappy.snap.t3mlite.spun as spun
 
 def hash_t3m_surface(surface):
     ans = [surface.EulerCharacteristic]
-    ans += sorted(list(surface.EdgeWeights))
-    ans += sorted(list(surface.Quadvector))
+    ans += sorted(surface.EdgeWeights)
+    ans += sorted(surface.Quadvector)
     return ans
 
 
@@ -66,8 +66,8 @@ def compare_cusped(snappy_manifold):
     t = R.getNumberOfTetrahedra()
     regina_surfaces = list(vertex_surfaces(R))
     r_hashes = sorted(
-        sorted(sorted(int(S.getQuadCoord(i, j).stringValue())
-                      for i in range(t) for j in range(3)))
+        sorted(int(S.getQuadCoord(i, j).stringValue())
+                      for i in range(t) for j in range(3))
         for S in regina_surfaces)
     r_slopes = sorted(map(regina_boundary_slope, regina_surfaces))
 

snappy/snap/test.py

@@ -1,10 +1,40 @@
-from ..sage_helper import _within_sage, doctest_modules
-from ..pari import pari
+from snappy import testing
 import snappy
-import snappy.snap as snap
-import getopt
-import sys
 
+from snappy.sage_helper import _within_sage
+from snappy.pari import pari
+
+from snappy import snap
+
+modules = [
+    snap,
+    snap.t3mlite.linalg,
+    snap.t3mlite.mcomplex,
+    snap.t3mlite.perm4,
+    snap.t3mlite.spun,
+    snap.character_varieties,
+    snap.slice_obs_HKL,
+    snap.nsagetools,
+    snap.polished_reps,
+    snap.interval_reps,
+    snap.fundamental_polyhedron,
+    snap.peripheral.dual_cellulation,
+    snap.peripheral.link,
+    snap.peripheral.peripheral
+]
+
+def run_doctests(verbose=False, print_info=True):
+    globs = {'Manifold':snappy.Manifold,
+             'ManifoldHP':snappy.ManifoldHP,
+             'Triangulation':snappy.Triangulation,
+             'Mcomplex':snappy.snap.t3mlite.Mcomplex,
+             'LinkSurface':snappy.snap.peripheral.link.LinkSurface}
+    return testing.doctest_modules(modules,
+                                   verbose=verbose,
+                                   print_info=print_info,
+                                   extraglobs=globs)
+
+run_doctests.__name__ = snap.__name__
 
 def _test_gluing_equations(manifold, shapes):
     """
@@ -30,7 +60,7 @@ def test_polished(dec_prec=200):
         return snap.shapes.gluing_equation_error(eqns, shapes)
 
     def test_census(name, census):
-        manifolds = [M for M in census]
+        manifolds = list(census)
         print('Checking gluing equations for %d %s manifolds' % (len(manifolds), name))
         max_error = pari(0)
         for i, M in enumerate(manifolds):
@@ -100,51 +130,5 @@ def big_test():
         test_holonomy()
         test_fields()
 
-
-def run_doctests(verbose=False, print_info=True):
-    from snappy.snap.t3mlite import perm4
-    from snappy.snap.t3mlite import linalg
-    from snappy.snap.t3mlite import spun
-    from snappy.snap.t3mlite import mcomplex
-    from snappy.snap import slice_obs_HKL
-    from snappy.snap import character_varieties
-    from snappy.snap import nsagetools
-    from snappy.snap import polished_reps
-    from snappy.snap import interval_reps
-    from snappy.snap import fundamental_polyhedron
-    from snappy.snap.peripheral import dual_cellulation
-    from snappy.snap.peripheral import link
-    from snappy.snap.peripheral import peripheral
-
-    modules = [
-        perm4,
-        mcomplex,
-        linalg,
-        spun,
-        character_varieties,
-        nsagetools,
-        slice_obs_HKL,
-        polished_reps,
-        snap,
-        interval_reps,
-        fundamental_polyhedron,
-        dual_cellulation,
-        link,
-        peripheral,
-    ]
-
-    globs = {'Manifold':snappy.Manifold,
-             'ManifoldHP':snappy.ManifoldHP,
-             'Triangulation':snappy.Triangulation,
-             'Mcomplex':snappy.snap.t3mlite.Mcomplex,
-             'LinkSurface':snappy.snap.peripheral.link.LinkSurface
-    }
-
-    return doctest_modules(modules, extraglobs=globs,
-                           verbose=verbose, print_info=print_info)
-
-
 if __name__ == '__main__':
-    optlist, args = getopt.getopt(sys.argv[1:], 'v', ['verbose'])
-    verbose = len(optlist) > 0
-    run_doctests(verbose)
+    testing.run_doctests_as_main(run_doctests)

snappy/snap/utilities.py

@@ -12,9 +12,8 @@ from itertools import chain
 from ..pari import pari, PariError
 from .fundamental_polyhedron import Infinity
 if _within_sage:
-    from sage.all import matrix as sage_matrix, vector as sage_vector
-    from sage.rings.real_mpfr import RealField_class
-    from ..sage_helper import ComplexField_class
+    from ..sage_helper import matrix as sage_matrix, vector as sage_vector
+    from ..sage_helper import RealField_class, ComplexField_class
 
     def is_field(R):
         return isinstance(R, (SnapPyNumbers, RealField_class,
@@ -67,7 +66,7 @@ class Vector2(MatrixBase):
         if len(args) == 1:
             args = args[0]
         if len(args) == 2:
-            self.x, self.y = [number(t) for t in args]
+            self.x, self.y = (number(t) for t in args)
         else:
             raise ValueError('Invalid initialization for a Vector2.')
 
@@ -141,7 +140,7 @@ class Matrix2x2(MatrixBase):
         if len(args) == 1:
             args = tuple(chain(*args[0]))
         if len(args) == 4:
-            self.a, self.b, self.c, self.d = [number(x) for x in args]
+            self.a, self.b, self.c, self.d = (number(x) for x in args)
         else:
             raise ValueError('Invalid initialization for a Matrix2x2.')