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

snappy/verify/exceptions.py

@@ -34,9 +34,7 @@ The hierarchy is as follows:
 
       - CuspEquationExactVerifyError
       - CuspEquationLogLiftNumericalVerifyError
-    - CuspDevelopmentType
 
-      - CuspDevelopmentTypeExactVerifyError
   - TiltType
 
     - TiltInequalityNumericalVerifyError
@@ -46,16 +44,15 @@ The hierarchy is as follows:
   - ShapeType
 
     - ShapePositiveImaginaryPartNumericalVerifyError
-  - ConsistencyWithSnapPeaType
-
-    - ConsistencyWithSnapPeaNumericalVerifyError
 """
 
+
 class VerifyErrorBase(RuntimeError):
     """
     The base for all exceptions related to verification.
     """
 
+
 class NumericalVerifyError(VerifyErrorBase):
     """
     The base for all exceptions resulting from a failed numerical
@@ -63,12 +60,14 @@ class NumericalVerifyError(VerifyErrorBase):
     (typically by interval arithmetics).
     """
 
+
 class InequalityNumericalVerifyError(NumericalVerifyError):
     """
     The base for all exceptions resulting from a failed numerical
     verification of an inequality (typically by interval arithmetics).
     """
 
+
 class LogLiftNumericalVerifyError(NumericalVerifyError):
     """
     To verify a logarithmic gluing equation, the verify module will usually
@@ -84,29 +83,34 @@ class LogLiftNumericalVerifyError(NumericalVerifyError):
     failed.
     """
 
+
 class ExactVerifyError(VerifyErrorBase):
     """
     The base for all exceptions resulting from a failed verification of an
     equation using exact arithmetics.
     """
 
+
 class IsZeroExactVerifyError(VerifyErrorBase):
     """
     The base for all exceptions resulting from verifying that a desired
     quantity is zero using exact arithmetics.
     """
 
-class EquationType(object):
+
+class EquationType():
     """
     A base class to derive subclasses which indicate what kind of
     equation failed to be verified.
     """
 
+
 class EdgeEquationType(EquationType):
     """
     A base class indicating that an edge equation could not be verified.
     """
 
+
 class EdgeEquationExactVerifyError(ExactVerifyError,
                                    EdgeEquationType):
     """
@@ -116,11 +120,12 @@ class EdgeEquationExactVerifyError(ExactVerifyError,
 
     def __init__(self, value):
         self.value = value
-        
+
     def __str__(self):
         return ('Verification of a polynomial edge equation using exact '
                 'arithmetic failed: %r == 1' % self.value)
 
+
 class EdgeEquationLogLiftNumericalVerifyError(LogLiftNumericalVerifyError,
                                               EdgeEquationType):
     """
@@ -129,23 +134,26 @@ class EdgeEquationLogLiftNumericalVerifyError(LogLiftNumericalVerifyError,
     """
     def __init__(self, value):
         self.value = value
-        
+
     def __str__(self):
         return ('Numerical verification that logarthmic edge equation has '
                 'small error failed: %r == 2 Pi I' % self.value)
 
+
 class CuspConsistencyType(EquationType):
     """
     A base class indicating that verificatin of an equation involving a cusp
     failed.
     """
 
+
 class CuspEquationType(CuspConsistencyType):
     """
     A base class indicating that a cusp gluing equation (involving the
     shapes) failed.
     """
 
+
 class CuspEquationExactVerifyError(ExactVerifyError,
                                    CuspEquationType):
     """
@@ -155,11 +163,12 @@ class CuspEquationExactVerifyError(ExactVerifyError,
 
     def __init__(self, value, expected_value):
         self.value = value
-        
+
     def __str__(self):
         return ('Verification of a polynomial cusp equation using exact '
                 'arithmetic failed: %r == 1' % self.value)
 
+
 class CuspEquationLogLiftNumericalVerifyError(LogLiftNumericalVerifyError,
                                               CuspEquationType):
     """
@@ -169,42 +178,19 @@ class CuspEquationLogLiftNumericalVerifyError(LogLiftNumericalVerifyError,
     def __init__(self, value, expected_value):
         self.value = value
         self.expected_value = expected_value
-        
+
     def __str__(self):
         return ('Numerical verification that logarthmic cusp equation has '
                 'small error failed: '
                 '%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.
     """
 
+
 class TiltInequalityNumericalVerifyError(InequalityNumericalVerifyError,
                                          TiltType):
     """
@@ -233,6 +219,7 @@ class TiltProvenPositiveNumericalVerifyError(
                 'failed, tilt is actually positive. This is provably '
                 'not the proto-canonical triangulation: %r <= 0' % self.value)
 
+
 class TiltIsZeroExactVerifyError(IsZeroExactVerifyError,
                                  TiltType):
     """
@@ -245,11 +232,13 @@ class TiltIsZeroExactVerifyError(IsZeroExactVerifyError,
         return ('Verification that tilt is zero has failed using exact '
                 'arithmetic: %r == 0' % self.value)
 
+
 class ShapeType(EquationType):
     """
     Base class for failed verification of legal shapes.
     """
 
+
 class ShapePositiveImaginaryPartNumericalVerifyError(
     InequalityNumericalVerifyError,
     ShapeType):
@@ -263,25 +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,13 +7,15 @@ __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):
     def __nonzero__(self):
         return False
 
+
 class NonIntegralFillingsError(RuntimeError):
     """
     Exception raised when Manifold has non-integral fillings, e.g.,
@@ -25,10 +27,10 @@ class NonIntegralFillingsError(RuntimeError):
     def __str__(self):
         return ('Manifold has non-integral Dehn-filings: %s') % self.manifold
 
+
 @sage_method
 def check_logarithmic_gluing_equations_and_positively_oriented_tets(
         manifold, shape_intervals):
-
     """
     Given a SnapPy manifold manifold and complex intervals for the shapes
     shape_intervals that are certified to contain a solution to the
@@ -36,7 +38,7 @@ def check_logarithmic_gluing_equations_and_positively_oriented_tets(
     are also fulfilled and that all shapes have positive imaginary part.
     It will raise an exception if the verification fails.
     This is sufficient to prove that the manifold is indeed hyperbolic.
-    
+
     Since the given interval are supposed to contain a true solution of
     the rectangular gluing equations, the logarithmic gluing equations
     are known to be fulfilled up to a multiple of 2 pi i. Thus it is enough
@@ -48,7 +50,7 @@ def check_logarithmic_gluing_equations_and_positively_oriented_tets(
         sage: M = Manifold("m019")
         sage: check_logarithmic_gluing_equations_and_positively_oriented_tets(
         ...    M, M.tetrahedra_shapes('rect', intervals=True))
-        
+
 
     The SnapPy triangulation of the following hyperbolic manifold contains
     actually negatively oriented tetrahedra::
@@ -59,7 +61,7 @@ def check_logarithmic_gluing_equations_and_positively_oriented_tets(
         Traceback (most recent call last):
         ...
         ShapePositiveImaginaryPartNumericalVerifyError: Numerical verification that shape has positive imaginary part has failed: Im(0.4800996900657? - 0.0019533695046?*I) > 0
-        
+
 
     """
 
@@ -75,11 +77,11 @@ def check_logarithmic_gluing_equations_and_positively_oriented_tets(
                 shape)
 
     # Compute the logarithms of z, z', z''
-    logZ   = [             z.log() for z in shape_intervals ]
-    logZp  = [ (1 / (1 - z)).log() for z in shape_intervals ]
+    logZ = [             z.log() for z in shape_intervals ]
+    logZp = [ (1 / (1 - z)).log() for z in shape_intervals ]
     logZpp = [ ((z - 1) / z).log() for z in shape_intervals ]
 
-    # A list 
+    # A list
     #    log(z_0) log(z'_0) log(z''_0) log(z_1) log(z'_1) log (z''_1) ...
     logs = [ z for triple in zip(logZ, logZp, logZpp) for z in triple ]
 
@@ -101,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
@@ -113,7 +115,7 @@ def check_logarithmic_gluing_equations_and_positively_oriented_tets(
             raise exceptions.EdgeEquationLogLiftNumericalVerifyError(
                 LHSs[LHS_index])
         LHS_index += 1
-        
+
     # Then there are one, respectively, two equations per cusp
     for cusp_index in range(n_cusps):
 
@@ -134,11 +136,13 @@ def check_logarithmic_gluing_equations_and_positively_oriented_tets(
             # Advance to the next gluing equation
             LHS_index += 1
 
+
 @sage_method
-def verify_hyperbolicity(manifold, verbose = False, bits_prec = None,
-                         holonomy=False, fundamental_group_args = [], lift_to_SL=True):
+def verify_hyperbolicity(manifold, verbose=False, bits_prec=None,
+                         holonomy=False, fundamental_group_args=[], lift_to_SL=True):
     """
     Given an orientable SnapPy Manifold, verifies its hyperbolicity.
+
     Similar to HIKMOT's :py:meth:`verify_hyperbolicity`, the result is either
     ``(True, listOfShapeIntervals)`` or ``(False, [])`` if verification failed.
     ``listOfShapesIntervals`` is a list of complex intervals (elements in
@@ -151,7 +155,7 @@ def verify_hyperbolicity(manifold, verbose = False, bits_prec = None,
         sage: M = Manifold("m019")
         sage: M.verify_hyperbolicity() # doctest: +NUMERIC12
         (True, [0.780552527850? + 0.914473662967?*I, 0.780552527850? + 0.91447366296773?*I, 0.4600211755737? + 0.6326241936052?*I])
-    
+
         sage: M = Manifold("t02333(3,4)")
         sage: M.verify_hyperbolicity() # doctest: +NUMERIC9
         (True, [2.152188153612? + 0.284940667895?*I, 1.92308491369? + 1.10360701507?*I, 0.014388591584? + 0.143084469681?*I, -2.5493670288? + 3.7453498408?*I, 0.142120333822? + 0.176540027036?*I, 0.504866865874? + 0.82829881681?*I, 0.50479249917? + 0.98036162786?*I, -0.589495705074? + 0.81267480427?*I])
@@ -197,7 +201,7 @@ def verify_hyperbolicity(manifold, verbose = False, bits_prec = None,
 
     try:
         shape_intervals = manifold.tetrahedra_shapes(
-            'rect', bits_prec = bits_prec, intervals = True)
+            'rect', bits_prec=bits_prec, intervals=True)
     except (ValueError, RuntimeError):
         if verbose:
             print("Could not certify solution to rectangular gluing equations")