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

snappy/verify/krawczyk_shapes_engine.py

@@ -1,16 +1,15 @@
-from snappy import snap
-from snappy.sage_helper import _within_sage, SageNotAvailable
+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']
 
+
 class KrawczykShapesEngine:
 
     """
@@ -37,14 +36,14 @@ class KrawczykShapesEngine:
        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.
-       
+
     2. 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').
@@ -52,14 +51,14 @@ class KrawczykShapesEngine:
        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.
 
     3. For speed-up, the approximate inverse is always computed with
        double's. Some intermediate matrix computations are performed sparsely.
 
     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.
 
     Here is an example how to explicitly invoke the KrawczykShapesEngine::
@@ -72,15 +71,15 @@ class KrawczykShapesEngine:
         (0.6623589786223730129805? + 0.5622795120623012438992?*I, 0.6623589786223730129805? + 0.5622795120623012438992?*I, 0.6623589786223730129805? + 0.5622795120623012438992?*I)
 
     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)
+
     """
 
     def log_gluing_LHSs(self, shapes):
@@ -149,8 +148,8 @@ 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):
         """
@@ -170,38 +169,38 @@ class KrawczykShapesEngine:
             [  0.292? - 1.6666?*I   0.292? - 1.6666?*I   0.752? - 1.0340?*I]
             [ 0.5400? - 0.6327?*I  0.5400? - 0.6327?*I  -1.561? - 1.8290?*I]
             [ 0.5400? - 0.6327?*I -0.5400? + 0.6327?*I                    0]
-        
+
         """
 
         # 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 self.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)
 
     def log_gluing_LHS_derivatives_sparse(self, shapes):
         """
@@ -214,8 +213,8 @@ class KrawczykShapesEngine:
         # Similar to log_gluing_LHS
         BaseField = shapes[0].parent()
         zero = BaseField(0)
-        one  = BaseField(1)
-        
+        one = BaseField(1)
+
         gluing_LHS_derivatives = []
 
         # For each shape z
@@ -228,13 +227,13 @@ class KrawczykShapesEngine:
             for r, (a, b) in eqns_column:
                 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
                 column.append((r, derivative))
             gluing_LHS_derivatives.append(column)
         return gluing_LHS_derivatives
-    
+
     @staticmethod
     def matrix_times_sparse(m, sparse_m):
         """
@@ -253,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):
@@ -270,7 +269,7 @@ class KrawczykShapesEngine:
         """
         Compute the interval in the Krawczyk test.
 
-        It is given as 
+        It is given as
 
             K(z0, [z], f) := z0 - c * f(z0) + (Id - c * df([z])) * ([z] - z0)
 
@@ -280,7 +279,7 @@ class KrawczykShapesEngine:
            - f is the function taking the shapes to the errors of the logarithmic gluing equations
            - c is an approximate inverse of df
            - df([z]) is the derivative of f (interval-)evaluated for [z]
-           
+
         Note that z0 in self.initial_shapes which are complex intervals
         containing only one value (the candidate solution given initially).
 
@@ -289,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):
@@ -307,7 +307,7 @@ class KrawczykShapesEngine:
         # Compute c * df([z])
         p = KrawczykShapesEngine.matrix_times_sparse(
             self.approx_inverse, derivative)
-        
+
         # Compute Id - c * df([z])
         diff = self.identity - p
 
@@ -351,9 +351,10 @@ 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)])
 
-    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 KrawczykShapesEngine given an orientable SnapPy
         Manifold M, approximated solutions initial_shapes to the
@@ -388,18 +389,14 @@ 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.
 
         """
 
-        # 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)
@@ -417,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()
 
@@ -465,7 +462,7 @@ class KrawczykShapesEngine:
         """
         return shapes.apply_map(lambda z: z + (z - z) / 64)
 
-    def expand_until_certified(self, verbose = False):
+    def expand_until_certified(self, verbose=False):
         """
         Try Krawczyk iterations (i.e., expanding the shape intervals [z]
         by the Krawczyk interval K(z0, [z], f)) until we can certify they
@@ -475,7 +472,7 @@ class KrawczykShapesEngine:
         certified_shapes.
         Set verbose = True for printing additional information.
         """
-        
+
         # Initialize the interval shapes to be the initial shapes
         shapes = self.initial_shapes
 

snappy/verify/maximal_cusp_area_matrix/__init__.py

@@ -1,32 +1,25 @@
-from ...sage_helper import _within_sage, sage_method
-from ..cuspCrossSection import ComplexCuspCrossSection
-from ..shapes import compute_hyperbolic_shapes
-from ..mathHelpers import interval_aware_min
-from .cusp_tiling_engine import *
+from ...sage_helper import sage_method
+from ...matrix import matrix
 
-if _within_sage:
-    from sage.all import matrix
+from .cusp_tiling_engine import *
 
-__all__ = ['verified_maximal_cusp_area_matrix',
-           'triangulation_dependent_cusp_area_matrix']
+__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):
     """
-
-    sage: from snappy import Manifold
-    sage: M = Manifold("s776")
-    sage: 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?]
-
+    TESTS::
+
+        sage: from snappy import Manifold
+        sage: M = Manifold("s776")
+        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?]
     """
-
-
     hyperbolic, shapes = snappy_manifold.verify_hyperbolicity(
-        bits_prec = bits_prec)
-    
+        bits_prec=bits_prec)
+
     if not hyperbolic:
         raise Exception("Could not compute shape intervals for: "
                         "triangulation does not hyperbolic structure or "
@@ -42,74 +35,12 @@ 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?]
+    return matrix(rows)
 
-    
-
-    """
-
-    # 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 *= interval_aware_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)
-        
 def _doctest():
     import doctest
     doctest.testmod()
 
+
 if __name__ == '__main__':
     _doctest()
-