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

snappy/snap/nsagetools.py

@@ -1,16 +1,13 @@
 """
 Tools for use in Sage.
 """
-
-import os, sys, re, string, tempfile
+import string
 from ..sage_helper import _within_sage, sage_method
 
 if _within_sage:
-    import sage
-    from sage.all import (ZZ, vector, matrix, block_matrix, identity_matrix,
-                          gcd, prod, det, MatrixSpace, AbelianGroup, GroupAlgebra,
-                          SageObject, PolynomialRing, LaurentPolynomialRing)
-
+    from ..sage_helper import ZZ, vector, matrix, block_matrix, identity_matrix, gcd, prod, det
+    from ..sage_helper import MatrixSpace, PolynomialRing, LaurentPolynomialRing
+    from ..sage_helper import SageObject, AbelianGroup, GroupAlgebra
     from .polished_reps import polished_holonomy, MatrixRepresentation
     Id2 = MatrixSpace(ZZ, 2)(1)
 else:
@@ -36,15 +33,16 @@ def search_for_low_rank_triangulation(M, tries=100, target_lower_bound=0):
     return rank_upper_bound, rank_lower_bound, curr_best_tri
 
 
-#----------------------------------------------------------------
+# ----------------------------------------------------------------
 #
 #  Abelianization of the fundamental group
 #
-#----------------------------------------------------------------
+# ----------------------------------------------------------------
 
 def abelianize_word(word, gens):
     return vector(ZZ, [ word.count(g) - word.count(g.swapcase()) for g in gens])
 
+
 class MapToAbelianization(SageObject):
     """
     sage: M = Manifold('v2037')
@@ -108,6 +106,7 @@ class MapToAbelianization(SageObject):
     def __call__(self, word):
         return self._range(self._exponents_of_word(word))
 
+
 class MapToFreeAbelianization(MapToAbelianization):
     def range(self):
         return ZZ**self.elementary_divisors.count(0)
@@ -119,6 +118,7 @@ class MapToFreeAbelianization(MapToAbelianization):
 
 # Finding the longitude
 
+
 @sage_method
 def homological_longitude(manifold, cusp=None):
     """
@@ -162,18 +162,18 @@ def homological_longitude(manifold, cusp=None):
     G = manifold.fundamental_group()
     f = MapToFreeAbelianization(G)
     m, l = G.peripheral_curves()[cusp]
-    kernel_basis =  matrix(ZZ, [f(m), f(l)]).left_kernel().basis()
+    kernel_basis = matrix(ZZ, [f(m), f(l)]).left_kernel().basis()
     if len(kernel_basis) >= 2:
         raise ValueError('Every curve on cusp is homologically trivial')
     if len(kernel_basis) == 0:
         return None
     return kernel_basis[0]
 
-#--------------------------------------------------------------
+# --------------------------------------------------------------
 #
 #  Computing the Alexander polynomial
 #
-#--------------------------------------------------------------
+# --------------------------------------------------------------
 
 
 class MapToGroupRingOfAbelianization(MapToAbelianization):
@@ -196,6 +196,7 @@ class MapToGroupRingOfAbelianization(MapToAbelianization):
         v = MapToAbelianization.__call__(self, word)
         return self.R.monomial(v)
 
+
 class MapToGroupRingOfFreeAbelianization(MapToFreeAbelianization):
     def __init__(self, fund_group, base_ring=ZZ):
         MapToFreeAbelianization.__init__(self, fund_group)
@@ -209,6 +210,7 @@ class MapToGroupRingOfFreeAbelianization(MapToFreeAbelianization):
         v = MapToFreeAbelianization.__call__(self, word)
         return prod([ g**v[i] for i, g in enumerate(self.R.gens())])
 
+
 def setup_fox_derivative(word, phi, var, involute=False):
     R = phi.range()
     if len(word) == 0:
@@ -230,6 +232,7 @@ def setup_fox_derivative(word, phi, var, involute=False):
 
     return R, phi_ims, fox_ders
 
+
 def fox_derivative(word, phi, var):
     """
     Given a homorphism phi of a group pi, computes
@@ -239,11 +242,11 @@ def fox_derivative(word, phi, var):
 
     R, phi_ims, fox_ders = setup_fox_derivative(word, phi, var)
     D = 0
-    curr_prod = R.one()
     for w in reverse_word(word):
-        D = fox_ders[w] + phi_ims[w]*D
+        D = fox_ders[w] + phi_ims[w] * D
     return D
 
+
 def fox_derivative_with_involution(word, phi, var):
     """
     The group ring Z[pi] has a natural involution iota sends
@@ -254,11 +257,11 @@ def fox_derivative_with_involution(word, phi, var):
     """
     R, phi_ims, fox_ders = setup_fox_derivative(word, phi, var, involute=True)
     D = 0
-    curr_prod = R.one()
     for w in reverse_word(word):
-        D = fox_ders[w] + D*phi_ims[w]
+        D = fox_ders[w] + D * phi_ims[w]
     return D
 
+
 # It's best to deal with matrices of polynomials rather than Laurent
 # polynomials, so we need to be able to clear denominators.  This add
 # to the complexity of the code.
@@ -303,6 +306,8 @@ def alexander_polynomial_basic(G, phi):
     M = matrix(P, [[ convert_laurent_to_poly(p, minexp, P) for p in row]
                    for row in M])
     alex_poly = gcd(M.minors(G.num_generators() - 1))
+    if alex_poly == 0:
+        return alex_poly
     # Normalize it
     return convert_laurent_to_poly(alex_poly, minimum_exponents( [alex_poly] ), P)
 
@@ -325,21 +330,27 @@ def alexander_polynomial(manifold, **kwargs):
         sage: N.alexander_polynomial()
         a^2*b + a*b^2 + a*b + a + b
 
-    Any provided keyword arguments are passed to fundamental_group and
+    Any provided keyword arguments are passed to
+    :meth:`fundamental_group <snappy.Triangulation.fundamental_group>` and
     so affect the group presentation used in the computation.
     """
+    if manifold.homology().order() != 'infinite':
+        raise ValueError(
+            "Alexander polynomial only defined for manifolds with "
+            "infinite homology.")
+
     ans = alexander_polynomial_group(manifold.fundamental_group(**kwargs))
     coeffs = ans.coefficients()
     if coeffs and coeffs[0] < 0:
         ans = -ans
     return ans
 
-#--------------------------------------------------------------
+# --------------------------------------------------------------
 #
 #  Computing the twisted torsion polynomials
 #     for deficiency one presentations.
 #
-#--------------------------------------------------------------
+# --------------------------------------------------------------
 
 
 class PhiAlpha():
@@ -358,39 +369,47 @@ class PhiAlpha():
         M[0,0], M[0,1], M[1,0], M[1,1] = a*A[0,0], a*A[0,1], a*A[1,0], a*A[1,1]
         return M
 
+
 def free_monoid_elt_to_string(elt):
     vars = elt.parent().variable_names()
     return "".join([e*vars[v] for v, e in elt._element_list])
 
+
 def inverse_word(word):
     L = list(word.swapcase())
     L.reverse()
     return "".join(L)
 
+
 def reverse_word(word):
     L = list(word)
     L.reverse()
     return "".join(L)
 
+
 def clean_RR(r, error):
     return 0 if abs(r) < error else r
 
+
 def clean_CC(z, error):
     CC = z.parent()
     return CC( clean_RR(z.real(),error), clean_RR(z.imag(), error) ) if not CC.is_exact() else z
 
+
 def univ_exponents(p):
     try:
         return [a[0] for a in p.exponents()]
     except TypeError:
         return p.exponents()
 
+
 def clean_laurent(p, error):
     R = p.parent()
     t = R.gen()
     new_coeffs = [clean_CC(z, error) for z in p.coefficients()]
     return sum( [a*t**n for a , n in zip(new_coeffs, univ_exponents(p))], R.zero())
 
+
 def clean_laurent_to_poly(p, error=10**-8):
     R = p.parent()
     P = PolynomialRing(R.base_ring(), R.variable_names())
@@ -402,20 +421,23 @@ def clean_laurent_to_poly(p, error=10**-8):
     m = min(exponents)
     return sum( [a*t**(n-m) for a,n in zip(cp.coefficients(), exponents)], P(0))
 
+
 def univ_abs(z):
     """
     Compute a reasonable choice for the absolute value of z.
     """
     try:
         return z.abs()
-    except:
+    except (TypeError, AttributeError):
         if hasattr(z, 'coefficients'):
             return max([0,] + [univ_abs(c) for c in z.coefficients()])
         else:
             return 0 if z == 0 else Infinity
 
+
 def univ_matrix_norm(A):
-    return max([0,] + [univ_abs(a) for a in A.list()])
+    return max([0] + [univ_abs(a) for a in A.list()])
+
 
 def matrix_has_small_entries(A, bound):
     if A.base_ring().is_exact():
@@ -423,6 +445,7 @@ def matrix_has_small_entries(A, bound):
     else:
         return univ_matrix_norm(A) < bound
 
+
 def last_square_submatrix(A):
     r, c = A.nrows(), A.ncols()
     if r <= c:
@@ -430,6 +453,7 @@ def last_square_submatrix(A):
     else:
         return A.matrix_from_rows( range( r - c, r) )
 
+
 def first_square_submatrix(A):
     r, c = A.nrows(), A.ncols()
     if r <= c:
@@ -441,25 +465,6 @@ def first_square_submatrix(A):
 class TorsionComputationError(Exception):
     pass
 
-@sage_method
-def hyperbolic_torsion(manifold, bits_prec=100, all_lifts=False, wada_conventions=False, phi=None):
-    """
-    Computes the hyperbolic torsion polynomial as defined in
-    `[DFJ] <http://arxiv.org/abs/1108.3045>`_::
-
-        sage: M = Manifold('K11n42')
-        sage: M.alexander_polynomial()
-        1
-        sage: tau = M.hyperbolic_torsion(bits_prec=200)
-        sage: tau.degree()
-        6
-    """
-    G = alpha = polished_holonomy(manifold, bits_prec=bits_prec, lift_to_SL2 = True)
-    if not all_lifts:
-        return compute_torsion(G, bits_prec, alpha, phi, wada_conventions=wada_conventions)
-    else:
-        return [compute_torsion(G, bits_prec, beta, phi, wada_conventions=wada_conventions)
-                for beta in alpha.all_lifts_to_SL2C()]
 
 def fast_determinant_of_laurent_poly_matrix(A):
     """
@@ -468,14 +473,17 @@ def fast_determinant_of_laurent_poly_matrix(A):
     polynomial entries.
     """
     R = A.base_ring()
-    minexp = minimum_exponents(A.list())
     P = R.polynomial_ring()
+    if A == 0:
+        return P(0)
+    minexp = minimum_exponents(A.list())
     MS = A.parent().change_ring(P)
     Ap = MS([convert_laurent_to_poly(p, minexp, P) for p in A.list()])
     return Ap.det()
 
-def compute_torsion(G, bits_prec, alpha=None, phi=None, phialpha = None,
-                    return_parts = False, return_as_poly=True,
+
+def compute_torsion(G, bits_prec, alpha=None, phi=None, phialpha=None,
+                    return_parts=False, return_as_poly=True,
                     wada_conventions=False, symmetry_test=True):
     if alpha:
         F = alpha('a').base_ring()
@@ -484,12 +492,19 @@ def compute_torsion(G, bits_prec, alpha=None, phi=None, phialpha = None,
     epsilon = ZZ(2)**(-bits_prec//3) if not F.is_exact() else None
     big_epsilon = ZZ(2)**(-bits_prec//5) if not F.is_exact() else None
     gens, rels = G.generators(), G.relators()
+
+    if len(rels) != len(gens) - 1:
+        raise ValueError(
+            "Algorithm to compute torsion requires a group presentation "
+            "with deficiency one")
+
     k = len(gens)
     if phi is None:
         phi = MapToGroupRingOfFreeAbelianization(G, F)
 
-    # Make sure this special algorithm applies.
-    assert  len(rels) == len(gens) - 1 and len(phi.range().gens()) == 1
+    if len(phi.range().gens()) != 1:
+        raise ValueError(
+            "Algorithm to compute torsion requires betti number 1")
 
     # Want the first variable to be homologically nontrivial
     i0 = [i for i, g in enumerate(gens) if phi(g) != 1][0]
@@ -502,18 +517,18 @@ def compute_torsion(G, bits_prec, alpha=None, phi=None, phialpha = None,
     if not wada_conventions:   # Using the conventions of our paper.
         d2 = [ [fox_derivative_with_involution(R, phialpha, g) for R in rels] for g in gens]
         d2 = block_matrix(d2, nrows=k, ncols=k-1)
-        d1 = [phialpha(g.swapcase())  - 1  for g in gens]
+        d1 = [phialpha(g.swapcase()) - 1 for g in gens]
         d1 = block_matrix(d1, nrows=1, ncols=k)
         dsquared = d1 * d2
 
     else: # Using those implicit in Wada's paper.
         d2 = [ [fox_derivative(R, phialpha, g) for g in gens] for R in rels]
         d2 = block_matrix(sum(d2, []), nrows=k-1, ncols=k)
-        d1 = [phialpha(g)  - 1  for g in gens]
+        d1 = [phialpha(g) - 1 for g in gens]
         d1 = block_matrix(d1, nrows=k, ncols=1)
         dsquared = d2 * d1
 
-    if not matrix_has_small_entries( dsquared , epsilon ):
+    if not matrix_has_small_entries( dsquared, epsilon ):
         raise TorsionComputationError("(boundary)^2 != 0")
 
     T = last_square_submatrix(d2)
@@ -542,24 +557,25 @@ def compute_torsion(G, bits_prec, alpha=None, phi=None, phialpha = None,
 
     if symmetry_test:
         coeffs = ans.coefficients()
-        error = max( [univ_abs(a-b) for a,b in zip(coeffs, reversed(coeffs))] )
+        error = max([univ_abs(a-b) for a,b in zip(coeffs, reversed(coeffs))], default=0)
         if (not F.is_exact() and error > epsilon) or (F.is_exact() and error != 0):
             raise TorsionComputationError("Torsion polynomial doesn't seem symmetric")
 
     return ans
 
-#--------------------------------------------------------------
+# --------------------------------------------------------------
 #
 #  Computing the torsion polynomials
 #     for the *adjoint* representation
 #     i.e. the poly of Dubois-Yamaguichi
-#--------------------------------------------------------------
+# --------------------------------------------------------------
 
 
 def adjoint_action(A):
     a, b, c, d = A.list()
     return matrix( [[a**2, 2*a*b, b**2],[a*c,b*c+a*d,b*d],[c**2,2*c*d,d**2]] )
 
+
 def SL2_to_SLN(A, N):
     F = A.base_ring()
     R = PolynomialRing(F, ['x', 'y'])
@@ -569,6 +585,7 @@ def SL2_to_SLN(A, N):
     image_vectors = [m(X, Y) for m in monomials]
     return matrix(F, [[v.monomial_coefficient(m) for m in monomials] for v in image_vectors])
 
+
 class PhiAlpha3():
     def __init__(self, phi, alpha):
         self.base_ring = phi.range()
@@ -588,6 +605,7 @@ class PhiAlpha3():
 
         return M
 
+
 class PhiAlphaN():
     def __init__(self, phi, alpha, N):
         self.base_ring = phi.range()
@@ -607,11 +625,40 @@ class PhiAlphaN():
 
         return M
 
+
 def test_rep(G, phialpha):
     def manually_apply_word(w):
         return prod(phialpha(x) for x in w)
     return max([univ_matrix_norm(manually_apply_word(R) - 1) for R in G.relators()])
 
+
+@sage_method
+def hyperbolic_torsion(manifold, bits_prec=100, all_lifts=False, wada_conventions=False, phi=None):
+    """
+    Computes the hyperbolic torsion polynomial as defined in
+    `[DFJ] <http://arxiv.org/abs/1108.3045>`_::
+
+        sage: M = Manifold('K11n42')
+        sage: M.alexander_polynomial()
+        1
+        sage: tau = M.hyperbolic_torsion(bits_prec=200)
+        sage: tau.degree()
+        6
+    """
+    if manifold.homology().betti_number() != 1:
+        raise ValueError('Algorithm needs H^1(M; Z) = Z to be able to compute torsion')
+    H = manifold.fundamental_group()
+    if H.num_generators() != H.num_relators() + 1:
+        raise ValueError('Algorithm to compute torsion requires a group presentation '
+                         'with deficiency one')
+    G = alpha = polished_holonomy(manifold, bits_prec=bits_prec, lift_to_SL2=True)
+    if not all_lifts:
+        return compute_torsion(G, bits_prec, alpha, phi, wada_conventions=wada_conventions)
+    else:
+        return [compute_torsion(G, bits_prec, beta, phi, wada_conventions=wada_conventions)
+                for beta in alpha.all_lifts_to_SL2C()]
+
+
 @sage_method
 def hyperbolic_SLN_torsion(manifold, N, bits_prec=100):
     """
@@ -623,13 +670,20 @@ def hyperbolic_SLN_torsion(manifold, N, bits_prec=100):
         sage: [M.hyperbolic_SLN_torsion(N).degree() for N in [2, 3, 4]]
         [18, 27, 36]
     """
-
+    if manifold.homology().betti_number() != 1:
+        raise ValueError('Algorithm needs H^1(M; Z) = Z to be able to compute torsion')
+    H = manifold.fundamental_group()
+    if H.num_generators() != H.num_relators() + 1:
+        raise ValueError('Algorithm to compute torsion requires a group presentation '
+                         'with deficiency one')
     G = alpha = polished_holonomy(manifold, bits_prec)
     phi = MapToGroupRingOfFreeAbelianization(G, alpha('a').base_ring())
     phialpha = PhiAlphaN(phi, alpha, N)
-    assert test_rep(G, phialpha) < ZZ(2)^(bits_prec//2)
+    if not test_rep(G, phialpha) < ZZ(2)**(bits_prec // 2):
+        raise RuntimeError("Invalid representation")
     return compute_torsion(G, bits_prec, phialpha=phialpha, symmetry_test=False)
 
+
 @sage_method
 def hyperbolic_adjoint_torsion(manifold, bits_prec=100):
     """

snappy/snap/peripheral/__init__.py

@@ -1 +1 @@
-from .peripheral import peripheral_cohomology_basis 
+from .peripheral import peripheral_cohomology_basis

snappy/snap/peripheral/dual_cellulation.py

@@ -6,9 +6,11 @@ from ... import sage_helper
 from .. import t3mlite as t3m
 
 if sage_helper._within_sage:
-    from sage.all import (ZZ, matrix, vector, ChainComplex, Graph)
+    from ...sage_helper import ZZ, matrix, vector, ChainComplex
+    from sage.graphs.graph import Graph
 
-class DualCell(object):
+
+class DualCell():
     """
     A cell in the dual cellulation
     """
@@ -16,11 +18,13 @@ class DualCell(object):
         self.dual_cell = dual_cell
         self.index = dual_cell.index
 
+
 class Vertex(DualCell):
     """
     A vertex of the dual cellulation.
     """
 
+
 class Edge(DualCell):
     """
     An oriented edge of the dual cellulation. The orientation
@@ -31,6 +35,7 @@ class Edge(DualCell):
         DualCell.__init__(self, dual_cell)
         self.vertices = [None, None]
 
+
 class Face(DualCell):
     """
     A face of the dual cellulation, which is just an n-gon.  The
@@ -46,13 +51,14 @@ class Face(DualCell):
     def __repr__(self):
         return "<Face: %s>" % self.index
 
-class DualCellulation(object):
+
+class DualCellulation():
     """
     The dual cellulation to a triangulation of a surface.
     """
     def __init__(self, triangulation):
         self.dual_triangulation = triangulation
-        self.from_original = dict()
+        self.from_original = {}
         self.vertices = []
         self.edges = []
         self.faces = []
@@ -151,7 +157,7 @@ class DualCellulation(object):
         assert CD.homology() == CT.homology()
 
 
-class OneCycle(object):
+class OneCycle():
     """
     A cycle on the 1-skeleton of a DualCellulation.
     """
@@ -174,7 +180,7 @@ class OneCycle(object):
         G = Graph(multiedges=True)
         for edge in D.edges:
             if self.weights[edge.index] != 0:
-                i, j = [v.index for v in edge.vertices]
+                i, j = (v.index for v in edge.vertices)
                 G.add_edge(i, j, edge.index)
 
         assert G.num_verts() == G.num_edges()
@@ -187,7 +193,8 @@ class OneCycle(object):
             ans.append(OneCycle(self.cellulation, weights))
         return ans
 
-class OneCocycle(object):
+
+class OneCocycle():
     """
     A cocycle on the 1-skeleton of a DualCellulation.
     """
@@ -206,6 +213,7 @@ def doctest_globals():
     import link
     return {'LinkSurface':link.LinkSurface}
 
+
 if __name__ == '__main__':
     import doctest
     doctest.testmod(extraglobs=doctest_globals())

snappy/snap/peripheral/link.py

@@ -1,17 +1,17 @@
 r"""
 Studying the vertex links of triangulations of 3-manifolds.
 
-Recall that in t3m and SnapPea, a 3-simplex is oriented like this:
-
-     1
-    /|\
-   / | \
-  /  |  \
- 2---|---3
-  \  |  /
-   \ | /
-    \|/
-     0
+Recall that in t3m and SnapPea, a 3-simplex is oriented like this::
+
+         1
+        /|\
+       / | \
+      /  |  \
+     2---|---3
+      \  |  /
+       \ | /
+        \|/
+         0
 
 Now consider the truncated tetrahedron; there, each vertex gives rise to a
 small triangular face whose vertices correspond to edges of the original
@@ -40,9 +40,11 @@ TruncatedSimplexCorners = {
 VerticesOfFace = { F0 : (V1, V2, V3), F1 : (V0, V3, V2),
                    F2 : (V0, V1, V3), F3 : (V0, V2, V1) }
 
+
 def cusp_corner_label(v, w):
     return TruncatedSimplexCorners[v].index( v | w )
 
+
 class LinkSurface(surface.Surface):
     def __init__(self, t3m_triangulation):
         self.parent_triangulation = t3m_triangulation
@@ -90,7 +92,7 @@ class LinkSurface(surface.Surface):
             sign = edge.orientation_with_respect_to(tet, a, b)
             for (v, s) in [(a, sign), (b, -sign)]:
                 label = s*(edge.Index + 1)
-                i = TruncatedSimplexCorners[v].index(a|b)
+                i = TruncatedSimplexCorners[v].index(a | b)
                 tri = tet.CuspCorners[v]
                 tri.vertices[i].index = label
 
@@ -110,13 +112,15 @@ class LinkSphere(LinkSurface):
     22
     """
     def __init__(self, t3m_triangulation):
-         N = t3m_triangulation
-         assert len(N.Vertices) == 1 and N.Vertices[0].link_genus() == 0
-         LinkSurface.__init__(self, N)
+        N = t3m_triangulation
+        assert len(N.Vertices) == 1 and N.Vertices[0].link_genus() == 0
+        LinkSurface.__init__(self, N)
+
 
 def doctest_globals():
     import snappy.snap.t3mlite
-    return {'Mcomplex':snappy.snap.t3mlite.Mcomplex}
+    return {'Mcomplex': snappy.snap.t3mlite.Mcomplex}
+
 
 if __name__ == '__main__':
     import doctest