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

snappy/twister/main.py

@@ -1,6 +1,5 @@
 ### Required modules:
 # Some standard modules.
-from __future__ import print_function
 import os
 from random import choice
 from itertools import combinations
@@ -9,12 +8,6 @@ import snappy
 from plink import LinkManager
 from .twister_core import build_bundle, build_splitting, twister_version
 
-# Python 3 compatibility
-try:
-	basestring
-except NameError:  # Python 3
-	basestring = unicode = str
-
 surface_database_path = os.path.join(os.path.dirname(__file__), 'surfaces')
 surface_database = set(os.listdir(surface_database_path))
 version = twister_version()
@@ -23,7 +16,7 @@ def _get_surface(surface):
 	if isinstance(surface, tuple) and len(surface) == 2 and isinstance(surface[0], int) and isinstance(surface[1], int):
 		return LP_surface(surface[0], surface[1])
 	
-	if isinstance(surface, basestring):
+	if isinstance(surface, str):
 		# If surface is actually the contents of a surface file.
 		if surface.startswith('# A Twister surface file'):
 			return surface

snappy/upper_halfspace/__init__.py

@@ -0,0 +1,146 @@
+from ..matrix import make_matrix
+from ..sage_helper import _within_sage
+from ..exceptions import InsufficientPrecisionError
+from ..math_basics import is_ComplexIntervalFieldElement
+
+"""
+
+upper_halfspace contains methods relating to the upper halfspace model
+
+                 H^3 = { w = z + ti : t > 0 }
+
+with a PSL(2,C)-matrix m = [[a,b],[c,d]] acting as
+
+           w |-> (a * w + b)^-1 * (c * w + d)
+
+It also contains methods converting from the upper halfspace model to
+other models of hyperbolic space including the conversion psl2c_to_o13.
+
+Points on the boundary C union {infty} of H^3 can be stored by either
+assigning a complex number or the sentinel
+upper_halfspace.ideal_point.Infinity to a variable. Functions using this
+representations of the boundary of H^3 are in ideal_point.
+
+Conventions:
+
+A SL(2,C)-matrix is a matrix constructed by snappy.matrix.matrix(...)
+(that is either snappy's own SimpleMatrix or a SageMath matrix type)
+with base_ring being a complex type (either a SnapPy.Number or one
+of SageMath's complex types including ComplexIntervalField, but not
+python's native complex type, e.g., 1 + 1j) and determinant being one.
+
+psl2c in a function name indicates that the function takes an SL(2,C)-matrix
+and the result (at least up rounding errors) does change when multiplying
+by -1.
+
+pgl2c in a function name indicates that the function takes any non-degenerate
+complex 2x2-matrix and uses the isomorphism PGL(2,C)=PSL(2,C).
+"""
+
+
+def sl2c_inverse(A):
+    return make_matrix([[A[1,1], -A[0, 1]], [-A[1, 0], A[0, 0]]])
+
+
+def psl2c_to_o13(A):
+    """
+    Converts matrix in PSL(2,C) to O13.
+
+    Python implementation of Moebius_to_O31 in matrix_conversion.c.
+    """
+
+    Aadj = _adjoint(A)
+
+    return make_matrix(
+        [ _o13_matrix_column(A, m, Aadj)
+          for m in _basis_vectors_sl2c(A.base_ring()) ]).transpose()
+
+
+def pgl2c_to_o13(m):
+    """
+    Converts matrix in PGL(2,C) to O13.
+
+    Python implementation of Moebius_to_O31 in matrix_conversion.c.
+    """
+    return psl2c_to_o13(m / m.det().sqrt())
+
+def complex_length_of_psl2c_matrix(m):
+    """
+    Complex length of translation corresponding to given PSL(2,C)
+    matrix.
+
+    Note that there is a branch cut here and we need to pick between
+    +/- 2 * arccosh(trace / 2).
+
+    We pick the cut with non-negative real part.
+
+    For non-verified computations, the real part will be non-negative.
+
+    For verified computations, the real part of the interval will contain
+    the non-negative real length. If the real length is very close to zero,
+    the real part of the interval might contain negative numbers as well.
+    """
+
+    tr = m.trace()
+    if not tr.real() >= 0:
+        # SageMath's arccosh has a branch cut on (-inf, -1].
+        #
+        # Ideally, the complex interval version would make a choice when
+        # we cross the branch cut (like it does for log).
+        #
+        # However, it returns (-pi, pi) as imaginary part when we cross
+        # branch cut.
+        #
+        # So flip trace to avoid the branch cut.
+
+        tr = -tr
+
+    l = 2 * _arccosh(tr / 2)
+
+    # The result it +/-l. But which one is it?
+
+    if l.real() >= 0:
+        # It is unambiguous.
+        return  l
+    if l.real() <= 0:
+        # It is unambiguous.
+        return -l
+
+    if is_ComplexIntervalFieldElement(l):
+        # It is ambiguous. Be conversative and take both.
+        return l.union(-l)
+
+    raise InsufficientPrecisionError(
+        "Encountered NaN when computing complex length of "
+        "matrix.\n"
+        "Trace: %r\n"
+        "Try increasing precision" % tr)
+
+def _basis_vectors_sl2c(CF):
+    return [ make_matrix([[ 1 , 0 ],
+                          [ 0, 1 ]], ring=CF),
+             make_matrix([[ 1 , 0 ],
+                          [ 0 ,-1 ]], ring=CF),
+             make_matrix([[ 0 , 1 ],
+                          [ 1 , 0 ]], ring=CF),
+             make_matrix([[ 0 , 1j],
+                          [-1j, 0 ]], ring=CF) ]
+
+def _adjoint(m):
+    return make_matrix([[ m[0][0].conjugate(), m[1][0].conjugate()],
+                        [ m[0][1].conjugate(), m[1][1].conjugate()]])
+
+
+def _o13_matrix_column(A, m, Aadj):
+    fAmj = A * m * Aadj
+
+    return [ (fAmj[0][0].real() + fAmj[1][1].real()) / 2,
+             (fAmj[0][0].real() - fAmj[1][1].real()) / 2,
+              fAmj[0][1].real(),
+              fAmj[0][1].imag() ]
+
+if _within_sage:
+    from ..sage_helper import arccosh as _arccosh
+else:
+    def _arccosh(z):
+        return z.arccosh()

snappy/upper_halfspace/ideal_point.py

@@ -0,0 +1,26 @@
+from ..matrix import vector
+
+__all__ = ['Infinity', 'ideal_point_to_r13']
+
+Infinity = 'Infinity'
+
+
+def ideal_point_to_r13(z, RF):
+    """
+    Takes a boundary point z of H^3, that is either a complex number
+    or Infinite, and a real field type.
+
+    Returns the corresponding unit light vector in the hyperboloid model.
+    """
+    if z == Infinity:
+        return vector([RF(1), RF(1), RF(0), RF(0)])
+
+    z_re = z.real()
+    z_im = z.imag()
+    z_abs_sqr = z_re**2 + z_im**2
+    denom = z_abs_sqr + 1
+
+    return vector([RF(1),
+                   (z_abs_sqr - 1) / denom,
+                   2 * z_re / denom,
+                   2 * z_im / denom])

snappy/verify/__init__.py

@@ -1,17 +1,13 @@
 from .interval_newton_shapes_engine import *
 from .krawczyk_shapes_engine import *
 
-from .cuspCrossSection import *
-
-from .verifyHyperbolicity import *
-from .verifyCanonical import *
-from .cuspTranslations import *
-from .cusp_shapes import *
+from .hyperbolicity import *
+from .canonical import *
+from .cusp_translations import *
 from .volume import *
 from .complex_volume import *
 from .interval_tree import *
-from .maximal_cusp_area_matrix import *
 
 # Choice of algorithm for finding intervals
 CertifiedShapesEngine = KrawczykShapesEngine
-#CertifiedShapesEngine = IntervalNewtonShapesEngine
+# CertifiedShapesEngine = IntervalNewtonShapesEngine

snappy/verify/{verifyCanonical.py → canonical.py}

@@ -1,17 +1,15 @@
-from __future__ import print_function
-
 from ..sage_helper import _within_sage, sage_method
 
-from .cuspCrossSection import RealCuspCrossSection
-from .squareExtensions import find_shapes_as_complex_sqrt_lin_combinations
-from . import verifyHyperbolicity
+from ..geometric_structure.cusp_neighborhood.real_cusp_cross_section import RealCuspCrossSection
+from ..snap.t3mlite import simplex
+
+from .square_extensions import find_shapes_as_complex_sqrt_lin_combinations
+from . import edge_equations
+from . import hyperbolicity
 from . import exceptions
 from ..exceptions import SnapPeaFatalError
 
-from ..snap import t3mlite as t3m
-
 if _within_sage:
-    from sage.rings.real_mpfi import RealIntervalField
     from sage.rings.complex_interval_field import ComplexIntervalField
     from ..pari import prec_dec_to_bits, prec_bits_to_dec
 
@@ -28,23 +26,25 @@ default_exact_bits_prec_and_degrees = [( 212, 10),
                                        (1000, 20),
                                        (2000, 20)]
 
-_num_tries_canonize = 3
+_num_tries_kernel_canonize = 3
 _max_tries_verify_penalty = 9
 
+
 class FindExactShapesError(RuntimeError):
     """
     Raised when snap failed to find the exact shapes using the LLL-algorithm
     for a manifold.
     """
 
+
 @sage_method
-def interval_checked_canonical_triangulation(M, bits_prec = None):
+def interval_checked_canonical_triangulation(M, bits_prec=None):
     """
     Given a canonical triangulation of a cusped (possibly non-orientable)
     manifold M, return this triangulation if it has tetrahedral cells and can
     be verified using interval arithmetics with the optional, given precision.
     Otherwise, raises an Exception.
-    
+
     It fails when we call it on something which is not the canonical
     triangulation::
 
@@ -70,7 +70,7 @@ def interval_checked_canonical_triangulation(M, bits_prec = None):
       Traceback (most recent call last):
       ...
       TiltInequalityNumericalVerifyError: Numerical verification that tilt is negative has failed: 0.?e-1... < 0
-    
+
     Has a cubical canonical cell::
 
        sage: M = Manifold("m412")
@@ -79,20 +79,20 @@ def interval_checked_canonical_triangulation(M, bits_prec = None):
        Traceback (most recent call last):
        ...
        TiltInequalityNumericalVerifyError: Numerical verification that tilt is negative has failed: 0.?e-1... < 0
-    
+
     """
 
     # Get verified shape intervals
-    shapes = M.tetrahedra_shapes('rect', intervals = True,
-                                 bits_prec = bits_prec)
+    shapes = M.tetrahedra_shapes('rect', intervals=True,
+                                 bits_prec=bits_prec)
 
     # Compute cusp cross sections
     c = RealCuspCrossSection.fromManifoldAndShapes(M, shapes)
 
     # Use interval arithmetics to verify hyperbolicity
-    verifyHyperbolicity.check_logarithmic_gluing_equations_and_positively_oriented_tets(
+    hyperbolicity.check_logarithmic_gluing_equations_and_positively_oriented_tets(
         M, shapes)
-    
+
     # Normalize cusp area. This is not needed when only 1 cusp
     if M.num_cusps() > 1:
         c.normalize_cusps()
@@ -121,6 +121,7 @@ def interval_checked_canonical_triangulation(M, bits_prec = None):
     # Return M
     return M
 
+
 @sage_method
 def exactly_checked_canonical_retriangulation(M, bits_prec, degree):
     """
@@ -136,12 +137,12 @@ def exactly_checked_canonical_retriangulation(M, bits_prec, degree):
        sage: K = exactly_checked_canonical_retriangulation(M, 300, 4)
 
     M's canonical cell decomposition has a cube, so non-tetrahedral::
-    
+
        sage: K.has_finite_vertices()
        True
 
     Has 12 tetrahedra after the retrianglation::
-    
+
       sage: K.num_tetrahedra()
       12
 
@@ -170,10 +171,10 @@ def exactly_checked_canonical_retriangulation(M, bits_prec, degree):
     # Check that the exact solutions form a complete hyperbolic structure
     # We convert to intervals to check that the shapes are positive and
     # the angles add up to 2pi and not some other multiple of 2pi.
-    c.check_polynomial_edge_equations_exactly()
+    edge_equations.check_polynomial_edge_equations_exactly(c.mcomplex)
     c.check_cusp_development_exactly()
     CIF = ComplexIntervalField(bits_prec)
-    c.check_logarithmic_edge_equations_and_positivity(CIF)
+    edge_equations.check_logarithmic_edge_equations_and_positivity(c.mcomplex, CIF)
 
     # Normalize cusp area. This is not needed when only 1 cusp
     if M.num_cusps() > 1:
@@ -193,56 +194,61 @@ def exactly_checked_canonical_retriangulation(M, bits_prec, degree):
         # Tilt is negative, return True
         if sign < 0:
             return True
-        
+
         # Tilt is zero, return False
         if sign == 0:
             return False
-        
+
         # Tilt is positive, raise exception
         if sign > 0:
             raise exceptions.TiltProvenPositiveNumericalVerifyError(interval)
 
     def index_of_face_corner(corner):
-        face_index = t3m.simplex.comp(corner.Subsimplex).bit_length() - 1
+        face_index = simplex.comp(corner.Subsimplex).bit_length() - 1
         return 4 * corner.Tetrahedron.Index + face_index
 
     # Opacities of all four faces of each tetrahedron, initialize with None.
     # The format is opacity of face 0, 1, 2, 3 of the first tetrahedron,
     # ... of second tetrahedron, ...
     opacities = (4 * len(c.mcomplex.Tetrahedra)) * [ None ]
-    
+
     # For each face of the triangulation
     for face in c.mcomplex.Faces:
         opacity = get_opacity(face.Tilt)
         for corner in face.Corners:
             opacities[index_of_face_corner(corner)] = opacity
-    
+
     if None in opacities:
         raise Exception("Mismatch with opacities")
 
-    # If there are transparent faces, this triangulation is just the
+    # If there are transparent faces, the given triangulation is just the
     # proto-canonical triangulation. We need to call into the SnapPea
     # kernel to retriangulate (introduces finite vertices)
-    if False in opacities:
+    if not all(opacities):
         return M._canonical_retriangulation(opacities)
 
-    # No transparent faces, this triangulation is the canonical triangulation.
+    # No transparent faces, this triangulation itself is the canonical cell
+    # decomposition.
     # Return it without introducing finite vertices.
     return M
 
-def _retrying_canonize(M):
+
+def _retrying_canonize(M) -> None:
     """
     Wrapper for SnapPea kernel's function to compute the proto-canonical
     triangulation in place. It will retry the kernel function if it fails.
-    Returns True if and only if the kernel function was successful eventually.
+    Raises an exception if it did not succeed eventually.
     """
-    for i in range(_num_tries_canonize):
+    err = ValueError('_num_tries_canonize is not positive.')
+
+    for i in range(_num_tries_kernel_canonize):
         try:
             M.canonize()
-            return True
-        except (RuntimeError, SnapPeaFatalError):
+            return
+        except (RuntimeError, SnapPeaFatalError) as e:
+            err = e
             M.randomize()
-    return False
+    raise err
 
 def _retrying_high_precision_canonize(M):
     """
@@ -250,43 +256,49 @@ def _retrying_high_precision_canonize(M):
     triangulation. It will retry the kernel function if it fails, switching
     to the quad-double implementation.
     Returns the proto-canonical triangulation if the kernel function was
-    successful eventually. Otherwise None. The original manifold is unchanged.
+    successful eventually. Otherwise, raises an exception.
+    The original manifold is unchanged.
     """
+
+    from .. import ManifoldHP
+
     # Make a copy of the manifold
     Mcopy = M.copy()
-    
+
     # Try with the given precision first
-    if _retrying_canonize(Mcopy):
+    try:
+        _retrying_canonize(Mcopy)
         return Mcopy
-        
-    # Then try with high precision.
-    Mhp = M.high_precision()
-    if _retrying_canonize(Mhp):
-        return Mhp
-
-    # Fail
-    return None
+    except (RuntimeError, SnapPeaFatalError) as e:
+        if isinstance(M, ManifoldHP):
+            # Already using high precision.
+            # Give up.
+            raise e
+        # Then try with high precision.
+        Mhp = M.high_precision()
+        _retrying_canonize(Mhp)
+        return Mhp.low_precision()
 
 def _print_exception(e):
     print('%s: %s' % (type(e).__name__, e))
 
+
 @sage_method
 def verified_canonical_retriangulation(
     M,
-    interval_bits_precs = default_interval_bits_precs,
-    exact_bits_prec_and_degrees = default_exact_bits_prec_and_degrees,
-    verbose = False):
-    
+    interval_bits_precs=default_interval_bits_precs,
+    exact_bits_prec_and_degrees=default_exact_bits_prec_and_degrees,
+    verbose=False):
     """
     Given some triangulation of a cusped (possibly non-orientable) manifold ``M``,
     return its canonical retriangulation. Return ``None`` if it could not certify
     the result.
 
-    To compute the canonical retriangulation, it first prepares the manifold 
+    To compute the canonical retriangulation, it first prepares the manifold
     (filling all Dehn-filled cusps and trying to find a proto-canonical
     triangulation).
     It then tries to certify the canonical triangulation using interval
-    arithmetics. If this fails, it uses snap (using `LLL-algorithm 
+    arithmetics. If this fails, it uses snap (using `LLL-algorithm
     <http://en.wikipedia.org/wiki/Lenstra%E2%80%93Lenstra%E2%80%93Lov%C3%A1sz_lattice_basis_reduction_algorithm>`_)
     to guess
     exact representations of the shapes in the shape field and then certifies
@@ -313,9 +325,6 @@ def verified_canonical_retriangulation(
     The exact arithmetics can take a long time. To circumvent it, use
     ``exact_bits_prec_and_degrees = None``.
 
-    More information on the canonical retriangulation can be found in the
-    SnapPea kernel ``canonize_part_2.c`` and in Section 3.1 of 
-    `Fominykh, Garoufalidis, Goerner, Tarkaev, Vesnin <http://arxiv.org/abs/1502.00383>`_.
 
     Canonical cell decomposition of ``m004`` has 2 tetrahedral cells::
 
@@ -335,7 +344,7 @@ def verified_canonical_retriangulation(
        True
        sage: K.num_tetrahedra()
        18
-    
+
     Canonical cell decomposition of ``m412`` is a cube and has exactly 8
     symmetries::
 
@@ -361,15 +370,21 @@ def verified_canonical_retriangulation(
     non-tetrahedral cells so interval arithmetics can't certify it)::
 
        sage: M = Manifold("m412")
-       sage: verified_canonical_retriangulation(M, exact_bits_prec_and_degrees = None)
+       sage: verified_canonical_retriangulation(M, exact_bits_prec_and_degrees = None) # doctest: +ELLIPSIS +IGNORE_EXCEPTION_DETAIL
+       Traceback (most recent call last):
+       ...
+       snappy.verify.exceptions.TiltInequalityNumericalVerifyError: Numerical verification that tilt is negative has failed: ... < 0
+
     """
 
     # This is the "outer" retry loop: it catches those verification
     # failures that can probably be fixed by taking a different
     # triangulation
-    
+
     tries_penalty_left = _max_tries_verify_penalty
 
+    err = ValueError("_max_tries_verify_penalty is not positive.")
+
     while tries_penalty_left > 0:
         try:
             # The "inner" retry loop: it catches those verification
@@ -383,11 +398,13 @@ def verified_canonical_retriangulation(
                 M, interval_bits_precs, exact_bits_prec_and_degrees,
                 verbose)
 
-        except (ZeroDivisionError, 
+        except (ZeroDivisionError,
                 exceptions.TiltProvenPositiveNumericalVerifyError,
                 exceptions.EdgeEquationExactVerifyError) as e:
 
-            # These three exceptions are probably raised due to the 
+            err = e
+
+            # These three exceptions are probably raised due to the
             # SnapPea kernel failures:
             # - flat tetrahedra in the proto-canonical triangulation
             # - this provably not being the proto-canonical triangulation
@@ -432,49 +449,41 @@ def verified_canonical_retriangulation(
                       "proto_canonize.")
                 print("Next step: Give up.")
 
-            return None
-        
-    return None
+            raise e
+
+    raise err
 
 def _verified_canonical_retriangulation(
         M, interval_bits_precs, exact_bits_prec_and_degrees,
         verbose):
+    """
+    Implements the "inner" retry loop of verified_canonical_retriangulation
 
-    # Implements the "inner" retry loop of verified_canonical_retriangulation
-
-    # If this returns None, it means that we have given up
-    # If it leaves Exceptions uncaught, the "outer" loop will randomize
-    # the triangulation.
-
-    num_complete_cusps = 0
-    num_incomplete_cusps = 0
-    for cusp_info in M.cusp_info():
-        if cusp_info['complete?']:
-            num_complete_cusps += 1
-        else:
-            num_incomplete_cusps += 1
+    Returns retriangulation or raises exception.
 
-    if not num_complete_cusps:
-        if verbose:
-            print("Failure: Due to no unfilled cusp.")
-            print("Next step: Give up.")
-        return None
+    Some exceptions are caught by the "outer" loop to retry, using that
+    the SnapPea kernel uses a randomized algorithm to fill incomplete cusps
+    (if applicable) and perform the flips to find the proto-canonical
+    triangulation.
+    """
 
-    # Dehn-fill manifold first
-    if num_incomplete_cusps:
-        Mfilled = M.filled_triangulation()
-    else:
+    if all(M.cusp_info('complete?')):
         Mfilled = M
+    else:
+        # Dehn-fill manifold first
+        Mfilled = M.filled_triangulation()
+        if not all(Mfilled.cusp_info('complete?')):
+            raise ValueError(
+                'Could not compute filled triangulation. '
+                'Are the filling coefficients co-prime integers?')
 
     # Try to compute proto-canonical triangulation
     Mcopy = _retrying_high_precision_canonize(Mfilled)
 
-    if not Mcopy:
-        if verbose:
-            print("Failure: In SnapPea kernel's proto_canonize()")
-            print("Next step: Give up.")
-        return None
-
+    err = ValueError(
+        'Neither interval_bits_precs nor exact_bits_prec_and_degrees was '
+        'non-empty.')
+    
     # First try interval arithmetics to verify
     if interval_bits_precs:
         for interval_bits_prec in interval_bits_precs:
@@ -484,7 +493,11 @@ def _verified_canonical_retriangulation(
             try:
                 return interval_checked_canonical_triangulation(
                     Mcopy, interval_bits_prec)
-            except (RuntimeError, exceptions.NumericalVerifyError) as e:
+            except (RuntimeError,
+                    ValueError, # Manifold.tetrahedra_shapes,
+                                # KrawczykShapesEngine.log_gluing_LHSs
+                    exceptions.NumericalVerifyError) as e:
+                err = e
                 if verbose:
                     _print_exception(e)
                     if isinstance(e, exceptions.NumericalVerifyError):
@@ -504,22 +517,26 @@ def _verified_canonical_retriangulation(
                 return exactly_checked_canonical_retriangulation(
                     Mcopy, bits_prec, degree)
             except FindExactShapesError as e:
+                err = e
                 if verbose:
                     _print_exception(e)
                     print("Failure: Could not find exact shapes.")
                     print("Next step: trying different method/precision")
 
-    return None
+    raise err
 
 _known_canonical_retriangulations = [
     ('m004', '\x02\x0e\x01\x01\x01-\x1b\x87'),
     ('m412', '\x0c\x80\xac\xff\x07\x05\x07\t\n\t\x08\t\n\x0b\x0b\n\x0b\xe4\xe4\xe4\xe4\xe4\xe1\xe1\xe1\xe1\xe1\xe1\xe1\xe1'),
     ('m137', '\x12\x00\xb0\xfa\xaf\x0f\x04\t\x0b\x08\x07\x07\n\x0c\x0e\r\n\x0f\x0f\r\x11\x11\x10\x10\x11\xb4\xe4\xe1\xe1\xe1\xb4\xe1\xe1\xb1\xe1\xb4\xe4\xe4\xe1\xb1\xe1\xe1\xb4\xe1') ]
-    
+
+
 def _test_against_known_canonical_retriangulations():
     from snappy import Manifold
     for name, bytes_ in _known_canonical_retriangulations:
-        M = Manifold(name); K = verified_canonical_retriangulation(M)
-        L = Manifold('empty'); L._from_bytes(bytes_)
-        if not len(K.isomorphisms_to(L)):
+        M = Manifold(name)
+        K = verified_canonical_retriangulation(M)
+        L = Manifold('empty')
+        L._from_bytes(bytes_)
+        if not K.isomorphisms_to(L):
             raise Exception('%s failed' % name)

snappy/verify/complex_volume/__init__.py

@@ -5,9 +5,10 @@ from .closed import *
 
 __all__ = ['verified_complex_volume_torsion']
 
+
 @sage_method
-def verified_complex_volume_torsion(manifold, bits_prec = None):
-    
+def verified_complex_volume_torsion(manifold, bits_prec=None):
+
     completeness = [
         cusp_info['complete?'] for cusp_info in manifold.cusp_info() ]