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

snappy/verify/exceptions.py

@@ -34,9 +34,7 @@ The hierarchy is as follows:
 
       - CuspEquationExactVerifyError
       - CuspEquationLogLiftNumericalVerifyError
-    - CuspDevelopmentType
 
-      - CuspDevelopmentTypeExactVerifyError
   - TiltType
 
     - TiltInequalityNumericalVerifyError
@@ -46,9 +44,6 @@ The hierarchy is as follows:
   - ShapeType
 
     - ShapePositiveImaginaryPartNumericalVerifyError
-  - ConsistencyWithSnapPeaType
-
-    - ConsistencyWithSnapPeaNumericalVerifyError
 """
 
 
@@ -190,32 +185,6 @@ class CuspEquationLogLiftNumericalVerifyError(LogLiftNumericalVerifyError,
                 '%r == %r' % (self.value, self.expected_value))
 
 
-class CuspDevelopmentType(CuspConsistencyType):
-    """
-    A base class indicating that there was a failure to find a consistent
-    assignment of side lengths to the Euclidean Horotriangles to form a
-    Euclidean Horotorus for a cusp.
-    """
-
-
-class CuspDevelopmentExactVerifyError(ExactVerifyError,
-                                      CuspDevelopmentType):
-    """
-    Raised when finding a consistent assignment of side lengths to the
-    Euclidean Horotriangles to form a Euclidean Horotorus for a cusp failed
-    using exact arithmetic.
-    """
-
-    def __init__(self, value1, value2):
-        self.value1 = value1
-        self.value2 = value2
-
-    def __str__(self):
-        return ('Inconsistency in the side lengths of the Euclidean '
-                'Horotriangles for a cusp: '
-                '%r = %r' % (self.value1, self.value2))
-
-
 class TiltType(EquationType):
     """
     A base class relating to tilts.
@@ -283,27 +252,3 @@ class ShapePositiveImaginaryPartNumericalVerifyError(
         return ('Numerical verification that shape has positive imaginary '
                 'part has failed: Im(%r) > 0' % self.value)
 
-
-class ConsistencyWithSnapPeaType(EquationType):
-    """
-    A base class for exceptions raised when there is a difference
-    between the values computed by the SnapPea kernel and by this module
-    for a given quantity.
-    """
-
-
-class ConsistencyWithSnapPeaNumericalVerifyError(
-    NumericalVerifyError,
-    ConsistencyWithSnapPeaType):
-    """
-    Exception raised when there is a significant numerical difference
-    between the values computed by the SnapPea kernel and by this module
-    for a given quantity.
-    """
-    def __init__(self, value, snappea_value):
-        self.value = value
-        self.snappea_value = snappea_value
-
-    def __str__(self):
-        return ('Inconsistency between SnapPea kernel and verify: '
-                '%r == %r' % (self.snappea_value, self.value))

snappy/verify/{verifyHyperbolicity.py → hyperbolicity.py}

@@ -7,8 +7,8 @@ __all__ = [
     'verify_hyperbolicity' ]
 
 if _within_sage:
-    from sage.all import pi
-    import sage.all
+    from sage.symbolic.constants import pi
+    from ..sage_helper import I
 
 
 class FalseTuple(tuple):
@@ -103,7 +103,7 @@ def check_logarithmic_gluing_equations_and_positively_oriented_tets(
     CIF = shape_intervals[0].parent()
     RIF = CIF.real_field()
     # 2 pi i in that field
-    two_pi_i = CIF(2 * pi * sage.all.I)
+    two_pi_i = CIF(2 * pi * I)
 
     # Index of the next gluing equation to check
     LHS_index = 0

snappy/verify/interval_newton_shapes_engine.py

@@ -1,4 +1,4 @@
-from ..matrix import matrix, vector, mat_solve
+from ..matrix import make_matrix, make_vector, mat_solve
 from .. import snap
 from ..sage_helper import _within_sage, sage_method
 
@@ -142,7 +142,7 @@ class IntervalNewtonShapesEngine:
             # Take log of the entire product
             gluing_LHSs.append(prod.log())
 
-        return vector(BaseField, gluing_LHSs)
+        return make_vector(gluing_LHSs, ring=BaseField)
 
     @staticmethod
     def log_gluing_LHS_derivatives(equations, shapes):
@@ -195,7 +195,7 @@ class IntervalNewtonShapesEngine:
 
             gluing_LHS_derivatives.append(row)
 
-        return matrix(BaseField, gluing_LHS_derivatives)
+        return make_matrix(gluing_LHS_derivatives, ring=BaseField)
 
     @staticmethod
     def interval_vector_mid_points(vec):
@@ -322,7 +322,7 @@ class IntervalNewtonShapesEngine:
         Given two vectors of intervals, return the vector of their unions,
         i.e., the smallest interval containing both intervals.
         """
-        return vector([a.union(b) for a, b in zip(vecA, vecB)])
+        return make_vector([a.union(b) for a, b in zip(vecA, vecB)])
 
     @staticmethod
     def certified_newton_iteration(equations, shape_intervals,
@@ -350,6 +350,7 @@ class IntervalNewtonShapesEngine:
 
         Intervals containing the true solution::
 
+            sage: from sage.all import vector
             sage: good_shapes = vector([
             ...       C.CIF(C.RIF(0.78055, 0.78056), C.RIF(0.91447, 0.91448)),
             ...       C.CIF(C.RIF(0.78055, 0.78056), C.RIF(0.91447, 0.91448)),
@@ -367,6 +368,7 @@ class IntervalNewtonShapesEngine:
 
         Intervals not containing a true solution::
 
+            sage: from sage.all import vector
             sage: bad_shapes = vector([
             ...       C.CIF(C.RIF(0.78054, 0.78055), C.RIF(0.91447, 0.91448)),
             ...       C.CIF(C.RIF(0.78055, 0.78056), C.RIF(0.91447, 0.91448)),
@@ -447,7 +449,7 @@ class IntervalNewtonShapesEngine:
             raise ValueError("Manifold needs to be orientable")
 
         # Initialize the shape intervals, they have zero length
-        self.initial_shapes = vector(
+        self.initial_shapes = make_vector(
             [self.CIF(shape) for shape in initial_shapes])
 
         # Get an independent set of gluing equations from snap

snappy/verify/interval_tree.py

@@ -277,13 +277,13 @@ class _IntervalTreeTester(IntervalTree):
 
     def __init__(self):
         self._entries = []
-        super(_IntervalTreeTester, self).__init__()
+        super().__init__()
 
     def insert(self, interval, value):
         # Insert in plain list for reference
         self._entries.append((interval, value))
         # Insert into red black tree
-        super(_IntervalTreeTester, self).insert(interval, value)
+        super().insert(interval, value)
 
     def brute_force_find(self, interval):
         """
@@ -300,7 +300,7 @@ class _IntervalTreeTester(IntervalTree):
                     self.brute_force_find(interval)))
 
     def check_consistency(self):
-        from sage.all import Infinity
+        from ..sage_helper import Infinity
         if self._root.isRed:
             raise Exception("Red root")
         _IntervalTreeTester._recursively_check_consistency(
@@ -308,7 +308,7 @@ class _IntervalTreeTester(IntervalTree):
 
     @staticmethod
     def _recursively_check_consistency(node, l, r):
-        from sage.all import Infinity
+        from ..sage_helper import Infinity
 
         if not node:
             return -Infinity, 0
@@ -370,7 +370,7 @@ class _IntervalTreeTester(IntervalTree):
 
     @staticmethod
     def run_test():
-        from sage.all import RIF, sin, Infinity
+        from ..sage_helper import RIF, Infinity, sin
 
         intervals = [
             RIF(sin(1.2 * i), sin(1.2 * i) + sin(1.43 * i) ** 2)

snappy/verify/krawczyk_shapes_engine.py

@@ -1,12 +1,10 @@
-from snappy import snap
-from snappy.sage_helper import _within_sage, sage_method
+from .. import snap
+from ..matrix import make_identity_matrix, make_matrix, make_vector
+
+from ..sage_helper import _within_sage, sage_method
 
 if _within_sage:
-    from sage.rings.complex_interval_field import ComplexIntervalField
-    from sage.rings.real_mpfi import RealIntervalField
-    from sage.all import ComplexDoubleField
-    from sage.all import matrix
-    from sage.modules.free_module_element import vector
+    from ..sage_helper import ComplexDoubleField, ComplexIntervalField, RealIntervalField
     from snappy.pari import prec_dec_to_bits
 
 __all__ = ['KrawczykShapesEngine']
@@ -75,12 +73,12 @@ class KrawczykShapesEngine:
     And here an example where the initial solution is somewhat off::
 
         sage: M = Manifold("m019")
-        sage: shapes = [ 0.78+0.91j, 0.79+0.92j, 0.5 + 0.63j ]
-        sage: C = KrawczykShapesEngine(M, shapes, bits_prec = 80)
+        sage: shapes = [0.780559+0.91449j, 0.780559+0.9144j, 0.46009+0.639j]
+        sage: C = KrawczykShapesEngine(M, shapes, bits_prec = 100)
         sage: C.expand_until_certified()
         True
-        sage: C.certified_shapes
-        (0.78? + 0.92?*I, 0.78? + 0.92?*I, 0.46? + 0.64?*I)
+        sage: C.certified_shapes # doctest: +ELLIPSIS
+        (0.7806? + 0.9145?*I, 0.7806? + 0.9145?*I, 0.460...? + 0.6326?*I)
 
     """
 
@@ -151,7 +149,7 @@ class KrawczykShapesEngine:
             # Take log of the entire product
             gluing_LHSs.append(prod.log())
 
-        return vector(BaseField, gluing_LHSs)
+        return make_vector(gluing_LHSs, ring=BaseField)
 
     def log_gluing_LHS_derivatives(self, shapes):
         """
@@ -202,7 +200,7 @@ class KrawczykShapesEngine:
 
             gluing_LHS_derivatives.append(row)
 
-        return matrix(BaseField, gluing_LHS_derivatives)
+        return make_matrix(gluing_LHS_derivatives, ring=BaseField)
 
     def log_gluing_LHS_derivatives_sparse(self, shapes):
         """
@@ -254,7 +252,7 @@ class KrawczykShapesEngine:
                     v += d * row[r]
                 result_row.append(v)
             rows.append(result_row)
-        return matrix(CIF, rows)
+        return make_matrix(rows, ring=CIF)
 
     @staticmethod
     def interval_vector_mid_points(vec):
@@ -290,6 +288,7 @@ class KrawczykShapesEngine:
 
         Do several Krawczyk operations to get a better solution::
 
+            sage: from sage.all import vector
             sage: M = Manifold("m019")
             sage: shapes = vector(ComplexIntervalField(53), [ 0.5+0.8j, 0.5+0.8j, 0.5+0.8j])
             sage: for i in range(15):
@@ -352,7 +351,7 @@ class KrawczykShapesEngine:
         i.e., the smallest interval containing both intervals.
         """
 
-        return vector([a.union(b) for a, b in zip(vecA, vecB)])
+        return make_vector([a.union(b) for a, b in zip(vecA, vecB)])
 
     @sage_method
     def __init__(self, M, initial_shapes, bits_prec=None, dec_prec=None):
@@ -391,7 +390,7 @@ class KrawczykShapesEngine:
 
         Or some non-hyperbolic manifolds::
 
-            sage: Manifold("t02333(1,0)").tetrahedra_shapes(intervals = True)
+            sage: Manifold("t02333(1,0)").tetrahedra_shapes(intervals = True) # doctest: +SKIP
             Traceback (most recent call last):
             ...
             RuntimeError: Could not certify shape intervals, either there are degenerate shapes or the precision must be increased.
@@ -415,14 +414,14 @@ class KrawczykShapesEngine:
             raise Exception("Manifold needs to be orientable")
 
         # Initialize the shape intervals, they have zero length
-        self.initial_shapes = vector(
+        self.initial_shapes = make_vector(
             [self.CIF(shape) for shape in initial_shapes])
 
         # Get an independent set of gluing equations from snap
         self.equations = snap.shapes.enough_gluing_equations(M)
         self._make_sparse_equations()
 
-        self.identity = matrix.identity(self.CIF, len(self.initial_shapes))
+        self.identity = make_identity_matrix(ring=self.CIF, n=len(self.initial_shapes))
 
         CDF = ComplexDoubleField()
 

snappy/verify/maximal_cusp_area_matrix/__init__.py

@@ -1,24 +1,18 @@
-from ...sage_helper import _within_sage, sage_method
-from ..cuspCrossSection import ComplexCuspCrossSection
-from ..shapes import compute_hyperbolic_shapes
-from ...math_basics import correct_min
-from .cusp_tiling_engine import *
-
-if _within_sage:
-    from sage.all import matrix
+from ...sage_helper import sage_method
+from ...matrix import matrix
 
-__all__ = ['verified_maximal_cusp_area_matrix',
-           'triangulation_dependent_cusp_area_matrix']
+from .cusp_tiling_engine import *
 
+__all__ = ['legacy_verified_maximal_cusp_area_matrix']
 
 @sage_method
-def verified_maximal_cusp_area_matrix(snappy_manifold, bits_prec=None):
+def legacy_verified_maximal_cusp_area_matrix(snappy_manifold, bits_prec=None):
     """
     TESTS::
 
         sage: from snappy import Manifold
         sage: M = Manifold("s776")
-        sage: verified_maximal_cusp_area_matrix(M) # doctest: +NUMERIC6
+        sage: legacy_verified_maximal_cusp_area_matrix(M) # doctest: +NUMERIC6
         [28.0000000000? 7.00000000000? 7.00000000000?]
         [7.00000000000?  28.000000000? 7.00000000000?]
         [7.00000000000? 7.00000000000?  28.000000000?]
@@ -41,68 +35,7 @@ def verified_maximal_cusp_area_matrix(snappy_manifold, bits_prec=None):
             rows[i][j] = v
             rows[j][i] = v
 
-    return _to_matrix(rows)
-
-
-def triangulation_dependent_cusp_area_matrix(
-                            snappy_manifold, verified, bits_prec=None):
-    """
-    Interesting case: t12521
-
-    Maximal cusp area matrix:
-
-    [ 77.5537626509970512653317518641810890989543820290380458409? 11.40953140648583915022197187043644048603871960228564151087?]
-    [11.40953140648583915022197187043644048603871960228564151087?     91.1461442179608339668518063027198489593908228325190920?]
-
-    This result:
-
-    [  77.553762651?   11.409531407?]
-    [  11.409531407? 5.508968850234?]
-
-    After M.canonize:
-
-    [  62.42018359?  11.409531407?]
-    [ 11.409531407? 15.1140644993?]
-    """
-    # Get shapes, as intervals if requested
-    shapes = compute_hyperbolic_shapes(
-        snappy_manifold, verified=verified, bits_prec=bits_prec)
-
-    # Compute cusp cross section, the code is agnostic about whether
-    # the numbers are floating-point or intervals.
-    # Note that the constructed cusp cross section will always be too "large"
-    # and we need to scale them down (since during construction the
-    # cross-section of each cusp will have one edge of length 1, the
-    # corresponding tetrahedron does not intersect in "standard" form.)
-    c = ComplexCuspCrossSection.fromManifoldAndShapes(snappy_manifold, shapes)
-
-    # If no areas are given, scale (up or down) all the cusps so that
-    # they are in standard form.
-    c.ensure_std_form(allow_scaling_up=True)
-
-    areas = c.cusp_areas()
-    RIF = areas[0].parent()
-
-    def entry(i, j):
-        if i > j:
-            i, j = j, i
-        result = areas[i] * areas[j]
-        if (i, j) in c._edge_dict:
-            result *= correct_min(
-                [ RIF(1), ComplexCuspCrossSection._exp_distance_of_edges(
-                        c._edge_dict[(i,j)])]) ** 2
-        return result
-
-    return _to_matrix([[entry(i, j) for i in range(len(areas))]
-                       for j in range(len(areas))])
-
-
-def _to_matrix(m):
-    # delayed import to avoid cycles
-    from snappy.SnapPy import matrix
-
-    return matrix(m)
-
+    return matrix(rows)
 
 def _doctest():
     import doctest

snappy/verify/maximal_cusp_area_matrix/cusp_tiling_engine.py

@@ -1,6 +1,7 @@
 from ...sage_helper import _within_sage
 from ...math_basics import correct_max
 
+from ...geometric_structure.cusp_neighborhood.complex_cusp_cross_section import ComplexCuspCrossSection
 from ...snap.kernel_structures import *
 from ...snap.fundamental_polyhedron import *
 from ...snap.mcomplex_base import *
@@ -8,15 +9,13 @@ from ...snap.t3mlite import simplex
 from ...snap import t3mlite as t3m
 from ...exceptions import InsufficientPrecisionError
 
-from ..cuspCrossSection import ComplexCuspCrossSection
 from ..upper_halfspace.ideal_point import *
 from ..interval_tree import *
 
 from .cusp_translate_engine import *
 
 if _within_sage:
-    from sage.all import matrix
-    import sage.all
+    from ...sage_helper import matrix
 
 import heapq
 
@@ -142,7 +141,7 @@ class CuspTilingEngine(McomplexEngine):
         return CuspTilingEngine(m, original_mcomplex, cusp_areas, translations)
 
     def __init__(self, mcomplex, original_mcomplex, cusp_areas, translations):
-        super(CuspTilingEngine, self).__init__(mcomplex)
+        super().__init__(mcomplex)
 
         self.original_mcomplex = original_mcomplex
         self.cusp_areas = cusp_areas

snappy/verify/maximal_cusp_area_matrix/cusp_translate_engine.py

@@ -3,7 +3,7 @@ from ...sage_helper import _within_sage
 from ..upper_halfspace.finite_point import *
 
 if _within_sage:
-    from sage.all import vector, matrix
+    from ...sage_helper import vector, matrix
 
 __all__ = ['CuspTranslateEngine']
 

snappy/verify/{realAlgebra.py → real_algebra.py}

@@ -26,7 +26,7 @@ def _find_unique_good_factor(polynomial, eval_method):
     one factor have this property, raise an exception.
     """
 
-    # Factor polynomial. Call eval_method on each factor which is suppsed to
+    # Factor polynomial. Call eval_method on each factor which is supposed to
     # return an interval. Get those factors for which the resulting interval
     # contains 0.
     good_factors = [ factor

snappy/verify/shapes.py

@@ -1,9 +1,11 @@
-from . import verifyHyperbolicity
+from . import hyperbolicity
 
 __all__ = ['compute_hyperbolic_shapes']
 
+from typing import Optional
 
-def compute_hyperbolic_shapes(manifold, verified, bits_prec=None):
+def compute_hyperbolic_shapes(manifold,
+                              verified : bool, bits_prec : Optional[int] = None):
 
     # Get shapes, as intervals if requested
     shapes = manifold.tetrahedra_shapes('rect', intervals=verified,
@@ -11,7 +13,7 @@ def compute_hyperbolic_shapes(manifold, verified, bits_prec=None):
 
     # Check it is a valid hyperbolic structure
     if verified:
-        verifyHyperbolicity.check_logarithmic_gluing_equations_and_positively_oriented_tets(
+        hyperbolicity.check_logarithmic_gluing_equations_and_positively_oriented_tets(
             manifold, shapes)
     else:
         # If not verified, just ask SnapPea kernel for solution type

snappy/verify/short_slopes.py

@@ -1,33 +1,19 @@
 from ..sage_helper import _within_sage
+from ..exceptions import InsufficientPrecisionError
+from ..math_basics import is_RealIntervalFieldElement, is_ComplexIntervalFieldElement
 
 import math
 
 if _within_sage:
-    from sage.all import gcd
-
-    from sage.rings.real_mpfi import is_RealIntervalFieldElement
-    from sage.rings.complex_interval import is_ComplexIntervalFieldElement
-
-    # python's sqrt only work for floats
-    # They would fail or convert to float losing precision
-    from sage.all import sqrt
+    from ..sage_helper import gcd
 else:
-    try:
-        # Python 3 has gcd in math
-        from math import gcd
-    except ImportError:
-        from fractions import gcd
-
-    # Otherwise, define our own sqrt which checks whether
-    # the given type defines a sqrt method and fallsback
-    # to python's log and sqrt which has the above drawback of
-    # potentially losing precision.
-    def sqrt(x):
-        if hasattr(x, 'sqrt'):
-            return x.sqrt()
-        return math.sqrt(x)
-
+    # Python 3 has gcd in math
+    from math import gcd
 
+# Reject computing short slopes if intervals for translations
+# are too wide (error is more than 1%).
+_min_diameter_translations = 0.01
+    
 def short_slopes_from_cusp_shape_and_area(
         cusp_shape, cusp_area, length=6):
     """
@@ -62,35 +48,32 @@ def translations_from_cusp_shape_and_area(
 
     if kernel_convention:
         inv_cusp_shape = 1 / cusp_shape.conjugate()
-        scale = sqrt(cusp_area / _imag(inv_cusp_shape))
+        scale = (cusp_area / _imag(inv_cusp_shape)).sqrt()
         return (scale * inv_cusp_shape, scale)
     else:
-        scale = sqrt(cusp_area / _imag(cusp_shape))
+        scale = (cusp_area / _imag(cusp_shape)).sqrt()
         return (scale, cusp_shape * scale)
 
-
 def short_slopes_from_translations(translations, length=6):
 
     m_tran, l_tran = translations
 
-    if _within_sage:
-        if is_ComplexIntervalFieldElement(m_tran):
-            raise Exception("Meridian translation expected to be real")
-        if is_RealIntervalFieldElement(l_tran):
-            raise Exception("Longitude translation expected to be complex")
+    if is_ComplexIntervalFieldElement(m_tran):
+        raise Exception("Meridian translation expected to be real")
+    if is_RealIntervalFieldElement(l_tran):
+        raise Exception("Longitude translation expected to be complex")
 
-        is_interval_1 = is_RealIntervalFieldElement(m_tran)
-        is_interval_2 = is_ComplexIntervalFieldElement(l_tran)
+    is_interval_1 = is_RealIntervalFieldElement(m_tran)
+    is_interval_2 = is_ComplexIntervalFieldElement(l_tran)
 
-        if is_interval_1 != is_interval_2:
-            raise Exception("Mismatch of non-intervals and intervals.")
+    if is_interval_1 != is_interval_2:
+        raise Exception("Mismatch of non-intervals and intervals.")
 
-        if is_interval_1:
-            return _verified_short_slopes_from_translations(translations, length)
+    if is_interval_1:
+        return _verified_short_slopes_from_translations(translations, length)
 
     return _unverified_short_slopes_from_translations(translations, length)
 
-
 def _unverified_short_slopes_from_translations(translations, length=6):
     m_tran, l_tran = translations
 
@@ -114,7 +97,7 @@ def _unverified_short_slopes_from_translations(translations, length=6):
         max_real_range_sqr = length ** 2 - _imag(total_l_tran) ** 2
 
         if max_real_range_sqr >= 0:
-            max_real_range = sqrt(max_real_range_sqr)
+            max_real_range = max_real_range_sqr.sqrt()
 
             if l == 0:
                 min_m = 1
@@ -136,7 +119,22 @@ def _verified_short_slopes_from_translations(translations, length=6):
     m_tran, l_tran = translations
 
     if not m_tran > 0:
-        raise Exception("Expected positive meridian translation")
+        raise Exception("Expected positive meridian translation.")
+
+    if not l_tran.imag() != 0:
+        raise InsufficientPrecisionError(
+            "Could not verify that longitude meridian translation "
+            "has non-trivial imaginary part.")
+
+    if m_tran.diameter() > _min_diameter_translations:
+        raise InsufficientPrecisionError(
+            "Meridian translation has insufficient precision to compute "
+            "a reasonable set of short slopes.")
+
+    if l_tran.diameter() > _min_diameter_translations:
+        raise InsufficientPrecisionError(
+            "Longitude translation has insufficient precision to compute "
+            "a reasonable set of short slopes.")
 
     RIF = m_tran.parent()
 
@@ -164,7 +162,7 @@ def _verified_short_slopes_from_translations(translations, length=6):
                 (- total_l_tran.real() + max_real_range) / m_tran)
 
             for m in range(min_m, max_m + 1):
-                if gcd(m, l) == 1:
+                if gcd(m, l) in [+1, -1]:
                     result.append((m, l))
 
     return result