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

snappy/verify/interval_newton_shapes_engine.py

@@ -1,22 +1,15 @@
+from ..matrix import make_matrix, make_vector, mat_solve
 from .. import snap
-from ..sage_helper import _within_sage, SageNotAvailable
+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.modules.free_module_element import vector
     from ..pari import prec_dec_to_bits
-    from sage.matrix.constructor import block_matrix
-    try:
-        from sage.matrix.constructor import MatrixFactory
-        matrix = MatrixFactory()
-    except ImportError:
-        # MatrixFactory was removed as of Sage 8.3.
-        # See https://trac.sagemath.org/ticket/25061
-        from sage.matrix.constructor import matrix
 
 __all__ = ['IntervalNewtonShapesEngine']
 
+
 class IntervalNewtonShapesEngine:
 
     """
@@ -48,14 +41,14 @@ class IntervalNewtonShapesEngine:
        We simply use Sage's complex interval type avoiding the need of
        converting n x n complex matrices into 2n x 2n real matrices as
        described Section 3.4 of the HIKMOT paper.
-       
+
     3. We avoid automatic differentiation.  We pick an independent set of
        equations of the following form and try to solve them:
 
                log(LHS) = 0
 
        where
-       
+
                LHS =  c * z0^a0 * (1-z0)^b0 *  z1^a1 * (1-z1)^b1 * ...
 
        with a, b and c's as returned by Manifold.gluing_equations('rect').
@@ -63,11 +56,11 @@ class IntervalNewtonShapesEngine:
        The derivative of log (LHS) with respect to zj is simply given by
 
                             aj/zj - bj/(1-zj)
-         
+
        and thus no need for automatic differentiation.
 
     In contrast to HIKMOT, we use and return Sage's native implementation of
-    (complex) interval arithmetic here, which allows for increased interoperability. 
+    (complex) interval arithmetic here, which allows for increased interoperability.
     Another advantage is that Sage supports arbitrary precision. Unfortunately,
     performance suffers and this implementation is 5-10 times slower than HIKMOT.
 
@@ -82,155 +75,6 @@ class IntervalNewtonShapesEngine:
 
     """
 
-    @staticmethod
-    def mat_solve(m, v):
-        """
-        Given a matrix m and a vector v of (complex) intervals, returns
-        the vector a such that v = m * a preserving interval
-        arithmetics: if m' is a matrix with values in the intervals of m and 
-        v' is a vector with values in the intervals of v, then the intervals
-        of the result a returned by this method are guaranteed to contain
-        the entries of m'^-1 * v'.
-
-        Sage already provides a method for inverting matrices. However, it
-        has a flaw and fails inverting interval matrices even though the
-        interval determinant is far from containing zero (it returns
-        unusable matrices with entries (-inf, inf).
-
-        Our implementation improves on this by swapping rows to avoid
-        diagonal entries close to zero during Gaussian elimination.
-
-        Setup a complex interval for example::
-        
-            sage: RIF = RealIntervalField(80)
-            sage: CIF = ComplexIntervalField(80)
-            sage: fuzzy_four = CIF(RIF(3.9999,4.0001),RIF(-0.0001,0.0001))
-
-        Construct a matrix/vector with complex interval coefficients. One entry
-        is a complex interval with non-zero diameter::
-
-            sage: m = matrix(CIF,
-            ...      [  [ fuzzy_four, 3, 2, 3],
-            ...         [          2, 3, 6, 2],
-            ...         [          2, 4, 1, 6],
-            ...         [          3, 2,-5, 2]])
-            sage: v = vector(CIF, [fuzzy_four, 2, 0 ,1])
-       
-        Now compute the solutions a to v = m * a::
-
-            sage: a = IntervalNewtonShapesEngine.mat_solve(m, v)
-            sage: a  # doctest: +ELLIPSIS
-            (1.5...? + 0.000?*I, -1.2...? + 0.000?*I, 0.34...? + 0.0000?*I, 0.24...? + 0.000?*I)
-            sage: m * a  # doctest: +ELLIPSIS
-            (4.0...? + 0.00?*I, 2.0...? + 0.00?*I, 0.0...? + 0.00?*I, 1.00? + 0.00?*I)
-
-        The product actually contains the vector v, we check entry wise::
- 
-            sage: [s in t for s, t in zip(v, m * a)]
-            [True, True, True, True]
-
-        """
-
-        # m = matrix(QQ,[[4,3,2,3],[2,3,6,2],[2,4,1,6],[3,2,-5,2]])
-        # v = vector(QQ,[4,2,0,1])
-
-        # For illustration, we use the following example of a matrix and
-        # vector (which for simplicity are not intervals here):
-        #
-        #      [ 4  3  2  3]
-        #  m = [ 2  3  6  2]       v = (4, 2, 0, 1)
-        #      [ 2  4  1  6]
-        #      [ 3  2 -5  2]
-        #
-
-        # Create a block matrix of the form
-        # [ 4  3  2  3| 4]
-        # [ 2  3  6  2| 2]
-        # [ 2  4  1  6| 0]
-        # [ 3  2 -5  2| 1]
-
-        m1 = block_matrix([[m,v.column()]])
-
-        # Iterate through the rows to apply row operations resulting
-        # in the left part being the identity matrix.
-        # After the i-th iteration the first i column will 
-
-        # For example, after the first iteration (i = 0), we get
-        # [    1   3/4   1/2   3/4|    1]
-        # [    0   3/2     5   1/2|    0]
-        # [    0   5/2     0   9/2|   -2]
-        # [    0  -1/4 -13/2  -1/4|   -2]
-
-        # For example, after the second iteration (i = 1), we get
-        # [    1     0   1/2  -3/5|  8/5]
-        # [    0     1     0   9/5| -4/5]
-        # [    0     0     5 -11/5|  6/5]
-        # [    0     0 -13/2   1/5|-11/5]
-
-        for i in range(len(v)):
-
-            # Assume i = 2, then we have the above matrix at the start
-            # of the iteration.
-
-            # We look for the largest absolute value in the i-th column on or
-            # below the diagonal and its index. In our example, the value
-            # occurs in the last row, so max_index = 1 because -11/2 is
-            # occurring at the spot one under the diagonal.
-            #
-            # Because we have intervals as input, we look for the interval
-            # with the largest infimum of the absolute value.
-            
-            max_index, max_val = max(enumerate(m1.column(i)[i:]),
-                                     key = lambda x:x[1].abs().lower())
-
-            if max_val.contains_zero():
-                raise ZeroDivisionError
-
-            # For numerical stability, swap rows to avoid diagonal entries
-            # that are close to zero. The results are still correct without
-            # this swapping of rows but the intervals would be less narrow.
-            
-            # In the above example, we swap the last two rows:
-            # [    1     0   1/2  -3/5|  8/5]
-            # [    0     1     0   9/5| -4/5]
-            # [    0     0 -13/2   1/5|-11/5]
-            # [    0     0     5 -11/5|  6/5]
-            
-            if max_index != 0:
-                m1[max_index+i], m1[i] = m1[i], m1[max_index+i]
-
-            # Divide the i-th row so that its i-th coefficient becomes 1
-            # [    1     0   1/2  -3/5|  8/5]
-            # [    0     1     0   9/5| -4/5]
-            # [    0     0     1 -2/65|22/65]
-            # [    0     0     5 -11/5|  6/5]
-            
-            m1[i] /= m1[i][i]
-
-            # Subtract multiples of the current row to make the i-th
-            # entries of all other rows zero.
-
-            # [      1       0       0  -38/65|  93/65]
-            # [      0       1       0     9/5|   -4/5]
-            # [      0       0       1   -2/65|  22/65]
-            # [      0       0       0 -133/65| -32/65]
-
-            for j in range(len(v)):
-                if i != j:
-                    m1[j] -= m1[j][i] * m1[i]
-
-
-        # After iterations, we have
-        # [       1        0        0        0|    11/7]
-        # [       0        1        0        0|-164/133]
-        # [       0        0        1        0|  46/133]
-        # [       0        0        0        1|  32/133]
-
-        # Return the last column
-        # (11/7, -164/133, 46/133, 32/133)
-
-        return m1.column(-1)
-
     @staticmethod
     def log_gluing_LHSs(equations, shapes):
         """
@@ -297,8 +141,8 @@ 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):
@@ -320,38 +164,38 @@ class IntervalNewtonShapesEngine:
             [ 0.2482? + 1.034...?*I  0.2482? + 1.034...?*I  -2.313? - 0.795...?*I]
             [ 0.5400? - 0.63...?*I -0.5400? + 0.63...?*I                    0]
             [...-0.4963? - 2.068?*I  1.0800? - 1.26...?*I   0.752? - 1.034...?*I]
-        
+
         """
 
         # Similar to log_gluing_LHS
         BaseField = shapes[0].parent()
         zero = BaseField(0)
-        one  = BaseField(1)
-        
+        one = BaseField(1)
+
         # 1 /    z for each shape z
-        shape_inverses           = [ one / shape         for shape in shapes ]
+        shape_inverses = [ one / shape for shape in shapes ]
 
         # 1 / (1-z) for each shape z
-        one_minus_shape_inverses = [ one / (one - shape) for shape in shapes ] 
+        one_minus_shape_inverses = [ one / (one - shape) for shape in shapes ]
 
         gluing_LHS_derivatives = []
         for A, B, c in equations:
             row = []
-            for a, b, shape_inverse,  one_minus_shape_inverse in zip(
+            for a, b, shape_inverse, one_minus_shape_inverse in zip(
                 A, B, shape_inverses, one_minus_shape_inverses):
                 # Equation for the derivative
                 #     derivative = (   a /      z -  b / (1-z) )
                 derivative = zero
                 if not a == 0:
-                    derivative  = BaseField(int(a)) * shape_inverse
+                    derivative = BaseField(int(a)) * shape_inverse
                 if not b == 0:
                     derivative -= BaseField(int(b)) * one_minus_shape_inverse
 
                 row.append( derivative )
-            
+
             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):
@@ -366,12 +210,12 @@ class IntervalNewtonShapesEngine:
 
     @staticmethod
     def newton_iteration(equations, shape_intervals,
-                         point_in_intervals = None,
-                         interval_value_at_point = None):
+                         point_in_intervals=None,
+                         interval_value_at_point=None):
         """
         Perform a Newton interval method of iteration for
         the function f described in log_gluing_LHSs.
-        
+
         Let z denote the shape intervals.
         Let z_center be a point close to the center point of the shape
         intervals (in the implementation, z_center is an interval of
@@ -393,7 +237,7 @@ class IntervalNewtonShapesEngine:
             sage: shapes = [ 0.7+1j, 0.7+1j, 0.5+0.5j ]
 
         Get the equations and initialize zero-length intervals from it::
-        
+
             sage: C = IntervalNewtonShapesEngine(M, shapes, bits_prec = 80)
             sage: C.initial_shapes
             (0.69999999999999995559107902? + 1*I, 0.69999999999999995559107902? + 1*I, 0.50000000000000000000000000? + 0.50000000000000000000000000?*I)
@@ -413,19 +257,19 @@ class IntervalNewtonShapesEngine:
 
             sage: M.tetrahedra_shapes('rect')
             [0.780552527850725 + 0.914473662967726*I, 0.780552527850725 + 0.914473662967726*I, 0.460021175573718 + 0.632624193605256*I]
-        
+
         Start with a rather big interval, note that the Newton interval method is
         stable in the sense that the interval size decreases::
-        
+
             sage: box = C.CIF(C.RIF(-0.0001,0.0001),C.RIF(-0.0001,0.0001))
             sage: shape_intervals = C.initial_shapes.apply_map(lambda shape: shape + box)
             sage: shape_intervals
             (0.700? + 1.000?*I, 0.700? + 1.000?*I, 0.500? + 0.500?*I)
-            sage: for i in range(7): 
+            sage: for i in range(7):
             ...     shape_intervals = IntervalNewtonShapesEngine.newton_iteration(C.equations, shape_intervals)
             sage: print(shape_intervals) # doctest: +ELLIPSIS
             (0.78055252785072483798...? + 0.91447366296772645593...?*I, 0.7805525278507248379869? + 0.914473662967726455938...?*I, 0.460021175573717872891...? + 0.632624193605256171637...?*I)
-        
+
 
         """
 
@@ -436,14 +280,13 @@ class IntervalNewtonShapesEngine:
         if interval_value_at_point is None:
             interval_value_at_point = IntervalNewtonShapesEngine.log_gluing_LHSs(
                 equations, point_in_intervals)
-    
+
         # Compute (DF)(z)
         derivatives = IntervalNewtonShapesEngine.log_gluing_LHS_derivatives(
             equations, shape_intervals)
-    
+
         return (  point_in_intervals
-                - IntervalNewtonShapesEngine.mat_solve(derivatives,
-                                                       interval_value_at_point))
+                - mat_solve(derivatives, interval_value_at_point))
 
     @staticmethod
     def interval_vector_is_contained_in(vecA, vecB):
@@ -479,12 +322,12 @@ 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,
-                                   point_in_intervals = None,
-                                   interval_value_at_point = None):
+                                   point_in_intervals=None,
+                                   interval_value_at_point=None):
         """
         Given shape intervals z, performs a Newton interval iteration N(z)
         as described in newton_iteration. Returns a pair (boolean, N(z)) where
@@ -496,10 +339,10 @@ class IntervalNewtonShapesEngine:
         See newton_iteration for the other parameters.
 
         This follows from Theorem 1 of `Zgliczynski's notes
-        <http://ww2.ii.uj.edu.pl/~zgliczyn/cap07/krawczyk.pdf>`_.  
+        <http://ww2.ii.uj.edu.pl/~zgliczyn/cap07/krawczyk.pdf>`_.
 
         Some examples::
-        
+
             sage: from snappy import Manifold
             sage: M = Manifold("m019")
             sage: C = IntervalNewtonShapesEngine(M, M.tetrahedra_shapes('rect'),
@@ -507,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)),
@@ -524,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)),
@@ -534,17 +379,17 @@ class IntervalNewtonShapesEngine:
 
         """
 
-
         new_shapes = IntervalNewtonShapesEngine.newton_iteration(
             equations, shape_intervals,
-            point_in_intervals = point_in_intervals,
-            interval_value_at_point = interval_value_at_point)
+            point_in_intervals=point_in_intervals,
+            interval_value_at_point=interval_value_at_point)
         return (
             IntervalNewtonShapesEngine.interval_vector_is_contained_in(
                 new_shapes, shape_intervals),
             new_shapes)
-        
-    def __init__(self, M, initial_shapes, bits_prec = None, dec_prec = None):
+
+    @sage_method
+    def __init__(self, M, initial_shapes, bits_prec=None, dec_prec=None):
         """
         Initializes the IntervalNewtonShapesEngine given an orientable SnapPy
         Manifold M, approximated solutions initial_shapes to the
@@ -575,11 +420,11 @@ class IntervalNewtonShapesEngine:
             sage: IntervalNewtonShapesEngine(M, M.tetrahedra_shapes('rect'), bits_prec = 53)
             Traceback (most recent call last):
             ...
-            Exception: Manifold needs to be orientable
+            ValueError: Manifold needs to be orientable
 
 
         Or some non-hyperbolic manifolds::
-        
+
             sage: Manifold("t02333(1,0)").tetrahedra_shapes(intervals = True)
             Traceback (most recent call last):
             ...
@@ -587,17 +432,13 @@ class IntervalNewtonShapesEngine:
 
         """
 
-        # Require sage
-        if not _within_sage:
-            raise SageNotAvailable("Sorry, the verify module can only be used within Sage")
-
         # Convert to precision in bits if necessary
         if dec_prec:
             self.prec = prec_dec_to_bits(dec_prec)
         elif bits_prec:
             self.prec = bits_prec
         else:
-            raise Exception("Need dec_prec or bits_prec")
+            raise ValueError("Need dec_prec or bits_prec")
 
         # Setup interval types of desired precision
         self.CIF = ComplexIntervalField(self.prec)
@@ -605,10 +446,10 @@ class IntervalNewtonShapesEngine:
 
         # Verify that manifold is orientable
         if not M.is_orientable():
-            raise Exception("Manifold needs to be orientable")
+            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
@@ -617,7 +458,7 @@ class IntervalNewtonShapesEngine:
         # Shapes have not been certified yet
         self.certified_shapes = None
 
-    def expand_until_certified(self, verbose = False):
+    def expand_until_certified(self, verbose=False):
         """
         Try Newton interval iterations, expanding the shape intervals
         until we can certify they contain a true solution.
@@ -625,7 +466,7 @@ class IntervalNewtonShapesEngine:
         certified_shapes.
         Set verbose = True for printing additional information.
         """
-        
+
         # In the equation for the Newton interval iteration
         #          N(z) = z_center - ((Df)(z))^-1 f(z_center)
         #
@@ -655,9 +496,8 @@ class IntervalNewtonShapesEngine:
                 is_certified, shapes = (
                     IntervalNewtonShapesEngine.certified_newton_iteration(
                         self.equations, shapes,
-                        point_in_intervals = self.initial_shapes,
-                        interval_value_at_point =
-                            interval_value_at_initial_shapes))
+                        point_in_intervals=self.initial_shapes,
+                        interval_value_at_point=interval_value_at_initial_shapes))
             except ZeroDivisionError:
                 if verbose:
                     print("Division by zero in interval Gaussian elimination")

snappy/verify/interval_tree.py

@@ -1,11 +1,10 @@
-from __future__ import print_function
-
 __all__ = ['IntervalTree']
 
-LEFT  = 0
+LEFT = 0
 RIGHT = 1
 
-class IntervalTree(object):
+
+class IntervalTree():
     """
     A data structure that can store (interval, value) pairs and quickly
     retrieve all values for which the interval overlaps with a given
@@ -42,7 +41,7 @@ class IntervalTree(object):
     Also see wikipedia or Cormen et al, *Introduction to Algorithms*.
     """
 
-    class _Node(object):
+    class _Node():
         def __init__(self, interval, value):
             # The interval and value of the inserted pair this node corresponds
             # to. The left endpoint of the interval is used as key for the
@@ -112,7 +111,7 @@ class IntervalTree(object):
 
         # Recurse down to the right
         IntervalTree._fill_recursive(node.children[RIGHT], interval, result)
-        
+
     def insert(self, interval, value):
         """
         Inserts (interval, value) where interval is an element in
@@ -132,7 +131,7 @@ class IntervalTree(object):
         else:
             # If empty tree, node becomes root
             self._root = node
-        
+
         # Root is always black
         self._root.isRed = False
 
@@ -174,13 +173,13 @@ class IntervalTree(object):
 
         # Step 3
         node.update_max_value()
-        
+
         return violation, node
 
     @staticmethod
     def _insert_and_fix(node, leaf):
         # Step 1: find whether to follow left or right child
-        
+
         branch = LEFT if leaf.interval.lower() <= node.interval.lower() else RIGHT
 
         # If we recursed down and have no more child, ...
@@ -194,7 +193,7 @@ class IntervalTree(object):
         # Otherwise, recurse further down the tree
         violation, node.children[branch] = IntervalTree._insert_fix_and_update_max(
             node.children[branch], leaf)
-        
+
         # We are unwinding the stack:
 
         # Check whether we have a violation. Skip step 2 if not.
@@ -214,7 +213,7 @@ class IntervalTree(object):
 
         # This node is black. Get all our red children to analyze the different
         # cases.
-        redChildren = [ 
+        redChildren = [
             (branch, child) for branch, child in enumerate(node.children)
             if IntervalTree._if_red(child) ]
 
@@ -262,6 +261,7 @@ class IntervalTree(object):
 #
 # TESTING
 
+
 class _IntervalTreeTester(IntervalTree):
     """
     A test rig for IntervalTree. It will keep a separate plain list of all
@@ -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,15 +300,15 @@ 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(
             self._root, -Infinity, +Infinity)
-        
+
     @staticmethod
     def _recursively_check_consistency(node, l, r):
-        from sage.all import Infinity
+        from ..sage_helper import Infinity
 
         if not node:
             return -Infinity, 0
@@ -325,7 +325,7 @@ class _IntervalTreeTester(IntervalTree):
         right_max, right_depth = (
             _IntervalTreeTester._recursively_check_consistency(
                 node.children[RIGHT], node.interval.lower(), r))
-            
+
         if not max(left_max, right_max, node.interval.upper()) == node.max_value:
             raise Exception("Maximum incorrect")
 
@@ -338,7 +338,7 @@ class _IntervalTreeTester(IntervalTree):
                     raise Exception("Red node has red child")
         else:
             left_depth += 1
-        
+
         return node.max_value, left_depth
 
     def print_tree(self):
@@ -353,25 +353,25 @@ class _IntervalTreeTester(IntervalTree):
             depth += 1
 
         _IntervalTreeTester.print_tree_recursively(node.children[0], depth)
-            
+
         align = 6 * depth
         if node.isRed:
             align += 3
 
-        print(align * " ", end = " ")
+        print(align * " ", end=" ")
         if node.isRed:
-            print("R", end = " ")
+            print("R", end=" ")
         else:
-            print("B", end = " ")
+            print("B", end=" ")
 
         print(node.interval.lower())
 
         _IntervalTreeTester.print_tree_recursively(node.children[1], depth)
-            
+
     @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)
             for i in range(200) ]
@@ -390,9 +390,11 @@ class _IntervalTreeTester(IntervalTree):
             raise Exception("Inconsistent number of intervals: %d %d" % (
                     num_true, num_have))
 
+
 def _doctest():
     import doctest
     doctest.testmod()
 
+
 if __name__ == '__main__':
     _doctest()