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

snappy/verify/complex_volume/adjust_torsion.py

@@ -1,7 +1,6 @@
 from ...sage_helper import _within_sage, sage_method
 if _within_sage:
-    from sage.all import pi
-    import sage.all
+    from sage.symbolic.constants import pi
 
 from .extended_bloch import *
 from ...snap import t3mlite as t3m
@@ -13,35 +12,39 @@ _move_to_three = {
     t3m.F0 : t3m.Perm4((3,0,1,2)),
     t3m.F1 : t3m.Perm4((0,3,1,2)),
     t3m.F2 : t3m.Perm4((0,1,3,2)),
-    t3m.F3 : t3m.Perm4((0,1,2,3))    
+    t3m.F3 : t3m.Perm4((0,1,2,3))
 }
 
 _move_from_three = {
     k : ~p for k, p in _move_to_three.items()
 }
 
+
 def _perm_for_q_tet(F, gluing):
     return _move_to_three[gluing.image(F)] * gluing * _move_from_three[F]
 
+
 def _compute_adjustment_for_face(face):
     canonical_corner = face.Corners[0]
-    tet     = canonical_corner.Tetrahedron
-    F       = canonical_corner.Subsimplex
-    gluing  = tet.Gluing[F]
+    tet = canonical_corner.Tetrahedron
+    F = canonical_corner.Subsimplex
+    gluing = tet.Gluing[F]
     other_F = gluing.image(F)
-    
+
     return -2 * _perm_for_q_tet(F, gluing)[0] * (-1) ** t3m.FaceIndex[other_F]
 
+
 def _compute_adjustment(mcomplex):
     """
     Given an mcomplex, compute the adjustment term to account for the
     triangulation not being ordered.
-    
+
     So far, only solves for the 3-torsion but 2-torsion remains
     """
     return sum([ _compute_adjustment_for_face(face)
                  for face in mcomplex.Faces ])
 
+
 @sage_method
 def verified_complex_volume_from_lifted_ptolemys(mcomplex, ptolemys):
     """
@@ -74,11 +77,10 @@ def normalize_by_pi_square_over_two(z):
     CIF = z.parent()
     RIF = CIF.real_field()
 
-    pi_square_over_two = RIF(pi**2/2)
+    pi_square_over_two = RIF(pi**2 / 2)
 
     # Round to integer
     q = (z.real().center() / pi_square_over_two.center()).round()
-    
+
     # Subtract multiple of pi^2/6
     return z - q * pi_square_over_two
-

snappy/verify/complex_volume/closed.py

@@ -1,16 +1,18 @@
 from ...sage_helper import _within_sage, sage_method
+from ...math_basics import prod
 
+from ...geometric_structure.cusp_neighborhood.complex_cusp_cross_section import ComplexCuspCrossSection
 from ...snap import peripheral
+from ...snap.t3mlite import simplex
 
 if _within_sage:
-    from sage.all import pi, xgcd, prod
-    import sage.all
+    from sage.symbolic.constants import pi
+    from ...sage_helper import I, xgcd
+
+from .. import hyperbolicity
 
 from .adjust_torsion import *
 from .compute_ptolemys import *
-from .. import verifyHyperbolicity
-from ..cuspCrossSection import ComplexCuspCrossSection
-from ...snap import t3mlite as t3m
 
 __all__ = ['verified_complex_volume_closed_torsion']
 
@@ -21,10 +23,10 @@ def _compute_holonomy(manifold, shapes):
     """
 
     # Compute z', z''
-    zp  = [ (1 / (1 - z)) for z in shapes ]
+    zp = [ (1 / (1 - z)) for z in shapes ]
     zpp = [ ((z - 1) / z) for z in shapes ]
 
-    # A list 
+    # A list
     #    log(z_0) log(z'_0) log(z''_0) log(z_1) log(z'_1) log (z''_1) ...
     cross_ratios = [ z for triple in zip(shapes, zp, zpp) for z in triple ]
 
@@ -36,6 +38,7 @@ def _compute_holonomy(manifold, shapes):
     return [ prod([l ** expo for l, expo in zip(cross_ratios, eqn)])
              for eqn in peripheral_eqns ]
 
+
 @sage_method
 def zero_lifted_holonomy(manifold, m, l, f):
     """
@@ -49,7 +52,7 @@ def zero_lifted_holonomy(manifold, m, l, f):
     multiple_of_pi = RIF(f*pi)
 
     # (m_fill, l_fill) Dehn-filling
-    m_fill, l_fill = [int(x) for x in manifold.cusp_info()[0]['filling']]
+    m_fill, l_fill = (int(x) for x in manifold.cusp_info()[0]['filling'])
 
     # Compute what the peripheral curves goes to right now
     p_interval = (m_fill * m + l_fill * l).imag() / multiple_of_pi
@@ -65,8 +68,8 @@ def zero_lifted_holonomy(manifold, m, l, f):
 
     # Compute by what multiple of 2 pi i to adjust
     g, a, b = xgcd(m_fill, l_fill)
-    m -= p * a * multiple_of_pi * sage.all.I
-    l -= p * b * multiple_of_pi * sage.all.I
+    m -= p * a * multiple_of_pi * I
+    l -= p * b * multiple_of_pi * I
 
     # For sanity, double check that we compute it right.
     p_interval = (m_fill * m + l_fill * l).imag() / multiple_of_pi
@@ -82,33 +85,38 @@ def zero_lifted_holonomy(manifold, m, l, f):
 
     return m, l
 
+
 @sage_method
-def verified_complex_volume_closed_torsion(manifold, bits_prec = None):
+def verified_complex_volume_closed_torsion(manifold, bits_prec=None):
     """
     Computes the verified complex volume (where the real part is the
     volume and the imaginary part is the Chern-Simons) for a given
     SnapPy.Manifold.
 
     Note that the result is correct only up to two torsion, i.e.,
-    up to multiples of pi^2/2. The method raises an exception if the
-    manifold is not oriented or has a filled cusp.
+    up to multiples of pi^2/2. The method expects an oriented manifold
+    with exactly one cusp which is filled, otherwise it raises an exception.
 
     If bits_prec is unspecified, the default precision of
-    SnapPy.Manifold, respectively, SnapPy.ManifoldHP will be used.
+    SnapPy.Manifold or SnapPy.ManifoldHP, respectively, will be used.
     """
 
     if manifold.num_cusps() != 1:
-        raise Exception("Only one cusped manifolds are supported")
+        raise ValueError(
+            "The method does not support the given manifold because "
+            "it does not have exactly one cusp.")
 
     if manifold.cusp_info()[0]['complete?']:
-        raise Exception("Only closed manifolds are supported")
+        raise ValueError(
+            "The method does not support the given manifold because "
+            "it is not a closed manifold.")
 
     # Compute tetrahedra shapes to arbitrary precision.
     shapes = manifold.tetrahedra_shapes(
-        'rect', bits_prec = bits_prec, intervals = True)
+        'rect', bits_prec=bits_prec, intervals=True)
 
     # Check it is a valid hyperbolic structure
-    verifyHyperbolicity.check_logarithmic_gluing_equations_and_positively_oriented_tets(
+    hyperbolicity.check_logarithmic_gluing_equations_and_positively_oriented_tets(
         manifold, shapes)
 
     # Compute holonomy
@@ -120,8 +128,8 @@ def verified_complex_volume_closed_torsion(manifold, bits_prec = None):
     # Keys for the dual edges in cusp triangulation
     cusp_dual_edges = [ (i, F, V)
              for i in range(manifold.num_tetrahedra())
-             for F in t3m.TwoSubsimplices
-             for V in t3m.ZeroSubsimplices
+             for F in simplex.TwoSubsimplices
+             for V in simplex.ZeroSubsimplices
              if F & V ]
 
     # Compute 1-cocycle in C^1(boundary; C^*) matching the holonomy
@@ -157,7 +165,4 @@ def verified_complex_volume_closed_torsion(manifold, bits_prec = None):
     # I.
     # Also add multiples of pi^2/2 to try to get the Chern-Simons part
     # between -pi^2/4 and pi^2/4.
-    return normalize_by_pi_square_over_two(complex_volume) / sage.all.I
-
-                
-
+    return normalize_by_pi_square_over_two(complex_volume) / I

snappy/verify/complex_volume/compute_ptolemys.py

@@ -2,6 +2,7 @@ from ...snap import t3mlite as t3m
 
 __all__ = ['lifted_ptolemys_from_cross_section']
 
+
 def _ptolemy_coordinate_key(tet_index, edge):
     return 'c_%d%d%d%d_%d' % (
         (edge & 8) >> 3,
@@ -10,8 +11,9 @@ def _ptolemy_coordinate_key(tet_index, edge):
         (edge & 1),
         tet_index)
 
+
 def lifted_ptolemys_from_cross_section(cusp_cross_section,
-                                       lifted_one_cocycle = None):
+                                       lifted_one_cocycle=None):
     """
     Given a cusp cross section, compute lifted Ptolemy coordinates
     (i.e., logarithms of the Ptolemy coordinates) returned as a dictionary
@@ -45,11 +47,11 @@ def lifted_ptolemys_from_cross_section(cusp_cross_section,
         # of a tetrahedron
         for i, (tet, perm) in enumerate(edge.embeddings()):
             # The two vertices of the tetrahedron's edge
-            v0   = perm.image(t3m.V0)
-            v1   = perm.image(t3m.V1)
-            v2   = perm.image(t3m.V2)
+            v0 = perm.image(t3m.V0)
+            v1 = perm.image(t3m.V1)
+            v2 = perm.image(t3m.V2)
             # The edge in the tetrahedron
-            e    = v0 | v1
+            e = v0 | v1
             # Face adjacent to the edge
             face = e | v2
 
@@ -84,5 +86,5 @@ def lifted_ptolemys_from_cross_section(cusp_cross_section,
 
             # Save Ptolemy coordinate in dictionary
             result[_ptolemy_coordinate_key(tet.Index, e)] = ptolemy
-            
+
     return result

snappy/verify/complex_volume/cusped.py

@@ -1,18 +1,19 @@
 from ...sage_helper import _within_sage, sage_method
 
 if _within_sage:
-    import sage.all
+    from ...sage_helper import I
+
+from .. import hyperbolicity
+from ...geometric_structure.cusp_neighborhood.complex_cusp_cross_section import ComplexCuspCrossSection
 
 from .adjust_torsion import *
 from .compute_ptolemys import *
-from .. import verifyHyperbolicity
-from ..cuspCrossSection import ComplexCuspCrossSection
-from ...snap import t3mlite as t3m
 
 __all__ = ['verified_complex_volume_cusped_torsion']
 
+
 @sage_method
-def verified_complex_volume_cusped_torsion(manifold, bits_prec = None):
+def verified_complex_volume_cusped_torsion(manifold, bits_prec=None):
     """
     Computes the verified complex volume (where the real part is the
     volume and the imaginary part is the Chern-Simons) for a given
@@ -28,10 +29,10 @@ def verified_complex_volume_cusped_torsion(manifold, bits_prec = None):
 
     # Compute tetrahedra shapes to arbitrary precision.
     shapes = manifold.tetrahedra_shapes(
-        'rect', bits_prec = bits_prec, intervals = True)
+        'rect', bits_prec=bits_prec, intervals=True)
 
     # Check it is a valid hyperbolic structure
-    verifyHyperbolicity.check_logarithmic_gluing_equations_and_positively_oriented_tets(
+    hyperbolicity.check_logarithmic_gluing_equations_and_positively_oriented_tets(
         manifold, shapes)
 
     # Compute cusp cross section. For computation of complex volume,
@@ -51,5 +52,5 @@ def verified_complex_volume_cusped_torsion(manifold, bits_prec = None):
     # By SnapPy convention, the volume is the real part, so divide by
     # I.
     # Also add multiples of pi^2/2 to try to get the Chern-Simons part
-    # between -pi^2/4 and pi^2/4. 
-    return normalize_by_pi_square_over_two(complex_volume) / sage.all.I
+    # between -pi^2/4 and pi^2/4.
+    return normalize_by_pi_square_over_two(complex_volume) / I

snappy/verify/complex_volume/extended_bloch.py

@@ -1,11 +1,9 @@
 from ...sage_helper import _within_sage, sage_method
 
 if _within_sage:
-    from sage.all import (ComplexBallField,
-                          RealField,
-                          Integer, exp, pi)
+    from sage.symbolic.constants import pi
+    from ...sage_helper import I, Integer, RealField, ComplexBallField, exp
 
-    import sage.all
 
 @sage_method
 def compute_z_and_parities_from_flattening_w0_w1(w0, w1):
@@ -27,6 +25,7 @@ def compute_z_and_parities_from_flattening_w0_w1(w0, w1):
 
     return l[0]
 
+
 @sage_method
 def compute_p_from_w_and_parity(w, parity):
     """
@@ -41,25 +40,26 @@ def compute_p_from_w_and_parity(w, parity):
     real_part = (w.imag().center() / RF(pi) - parity) / 2
     return 2 * Integer(real_part.round()) + parity
 
+
 @sage_method
 def compute_z_p_q_from_flattening_w0_w1(w0, w1):
     """
     Given w0 and w1 such that +- exp(w0) +- exp(-w1) = 1, compute
     a triple [z; p, q] such that
     w0 = log(z) + p * pi * i and w1 = -log(1-z) + q * pi * i.
-    
+
     While z is and the parities of p and q are verified, p and q are
     not verified in the following sense:
     w0 - p * pi * i and w1 + q * pi * i are likely to have imaginary
     part between -pi and pi, but this is not verified.
     """
-
     z, p_parity, q_parity = compute_z_and_parities_from_flattening_w0_w1(w0, w1)
 
     return (z,
             compute_p_from_w_and_parity(w0, p_parity),
             compute_p_from_w_and_parity(w1, q_parity))
 
+
 @sage_method
 def my_dilog(z):
     """
@@ -78,15 +78,16 @@ def my_dilog(z):
 
     return CIF(CBF(z).polylog(2))
 
+
 @sage_method
 def is_imaginary_part_bounded(z, v):
     """
     Check that the imaginary part of z is in (-v, v).
     """
-
     imag = z.imag()
     return -v < imag and imag < v
 
+
 @sage_method
 def compute_Neumanns_Rogers_dilog_from_flattening_w0_w1(w0, w1):
     """
@@ -94,7 +95,6 @@ def compute_Neumanns_Rogers_dilog_from_flattening_w0_w1(w0, w1):
     the complex volume given by R(z;p,q) (equation before Proposition 2.5 in
     Neumann's Extended Bloch group and the Cheeger-Chern-Simons class).
     """
-
     RIF = w0.parent().real_field()
     my_pi = RIF(pi)
 
@@ -103,9 +103,9 @@ def compute_Neumanns_Rogers_dilog_from_flattening_w0_w1(w0, w1):
 
     # Note that the values computed for log(z) and log(1-z)
     # are not verified to have the imaginary part between -pi and pi.
-    logZ         =    w0 - my_pi * p * sage.all.I
-    logOneMinusZ = - (w1 - my_pi * q * sage.all.I)
-    
+    logZ = w0 - my_pi * p * I
+    logOneMinusZ = - (w1 - my_pi * q * I)
+
     # Neumann's formula for the complex volume is
     #
     # (1) R(z; p, q) =   Li_2(  z) + ( term1 + term2) / 2 - pi^2/6
@@ -140,7 +140,7 @@ def compute_Neumanns_Rogers_dilog_from_flattening_w0_w1(w0, w1):
     # Similar considerations apply to (2) used when Re(z) > 1/2.
 
     term1 = logZ * logOneMinusZ
-    term2 = my_pi * sage.all.I * (p * logOneMinusZ + q * logZ)
+    term2 = my_pi * I * (p * logOneMinusZ + q * logZ)
 
     if z.real().center() < 0.5:
         # Check that we can apply equation (1)
@@ -157,6 +157,7 @@ def compute_Neumanns_Rogers_dilog_from_flattening_w0_w1(w0, w1):
 
         return (-term1 + term2) / 2 - my_dilog(1 - z)
 
+
 @sage_method
 def compute_complex_volume_of_simplex_from_lifted_ptolemys(index, ptolemys):
     """
@@ -179,6 +180,7 @@ def compute_complex_volume_of_simplex_from_lifted_ptolemys(index, ptolemys):
     # Compute Neumann's version of Roger's dilogarithm from flattening.
     return compute_Neumanns_Rogers_dilog_from_flattening_w0_w1(w0, w1)
 
+
 @sage_method
 def compute_complex_volume_from_lifted_ptolemys_no_torsion_adjustment(
         num_tetrahedra, ptolemys):

snappy/verify/{cuspTranslations.py → cusp_translations.py}

@@ -1,15 +1,16 @@
+from ..geometric_structure.cusp_neighborhood.complex_cusp_cross_section import ComplexCuspCrossSection
 from .shapes import compute_hyperbolic_shapes
-from .cuspCrossSection import ComplexCuspCrossSection
 
 __all__ = ['cusp_translations_for_manifold',
            'cusp_translations_for_neighborhood']
 
-def cusp_translations_for_manifold(manifold, verified, areas = None,
-                                   check_std_form = True,
-                                   bits_prec = None):
+
+def cusp_translations_for_manifold(manifold, verified, areas=None,
+                                   check_std_form=True,
+                                   bits_prec=None):
 
     shapes = compute_hyperbolic_shapes(
-        manifold, verified = verified, bits_prec = bits_prec)
+        manifold, verified=verified, bits_prec=bits_prec)
 
     # Compute cusp cross section, the code is agnostic about whether
     # the numbers are floating-point or intervals.
@@ -34,7 +35,7 @@ def cusp_translations_for_manifold(manifold, verified, areas = None,
         # Remark: If verified, RF(area) will result in intervals of
         # length 0.
         c.normalize_cusps([RF(area) for area in areas])
-        
+
         if check_std_form:
             # If so desired, make neighborhoods a bit smaller if necessary
             # so that they are "proven" to be in standard form.
@@ -42,7 +43,7 @@ def cusp_translations_for_manifold(manifold, verified, areas = None,
     else:
         # 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)
+        c.ensure_std_form(allow_scaling_up=True)
 
     # Note: the only code path avoiding ensure_std_form is through calling
     # all_translations on a CuspNeighborhood with verified = False,
@@ -55,13 +56,14 @@ def cusp_translations_for_manifold(manifold, verified, areas = None,
     # The result
     return c.all_normalized_translations()
 
+
 def cusp_translations_for_neighborhood(neighborhood,
-                                       verified = False, bits_prec = None):
+                                       verified=False, bits_prec=None):
 
     # Use the proto-canonical triangulation corresponding to the given
     # neighborhood and use Proposition 1 from cusp_neighborhoods.c to compute
     # the cusp areas
-    
+
     manifold = neighborhood.manifold()
     areas = [ neighborhood.volume(i) * 2 for i in range(manifold.num_cusps()) ]
 
@@ -77,8 +79,7 @@ def cusp_translations_for_neighborhood(neighborhood,
     # also should have given us areas corresponding to disjoint cusps to
     # begin with.
 
-    return cusp_translations_for_manifold(manifold, areas = areas,
-                                          check_std_form = verified,
-                                          verified = verified,
-                                          bits_prec = bits_prec)
-
+    return cusp_translations_for_manifold(manifold, areas=areas,
+                                          check_std_form=verified,
+                                          verified=verified,
+                                          bits_prec=bits_prec)

snappy/verify/edge_equations.py

@@ -0,0 +1,80 @@
+from .exceptions import *
+
+from ..snap.t3mlite import simplex
+
+def check_polynomial_edge_equations_exactly(mcomplex):
+    """
+    Check that the polynomial edge equations are fulfilled exactly.
+
+    We use the conjugate inverse to support non-orientable manifolds.
+    """
+
+    # For each edge
+    for edge in mcomplex.Edges:
+        # The exact value when evaluating the edge equation
+        val = 1
+
+        # Iterate through edge embeddings
+        for tet, perm in edge.embeddings():
+            # Accumulate shapes of the edge exactly
+            val *= _shape_for_edge_embedding(tet, perm)
+            
+        if not val == 1:
+            raise EdgeEquationExactVerifyError(val)
+
+def check_logarithmic_edge_equations_and_positivity(mcomplex, NumericalField):
+    """
+    Check that the shapes have positive imaginary part and that the
+    logarithmic gluing equations have small error.
+
+    The shapes are coerced into the field given as argument before the
+    logarithm is computed. It can be, e.g., a ComplexIntervalField.
+    """
+
+    # For each edge
+    for edge in mcomplex.Edges:
+
+        # The complex interval arithmetic value of the logarithmic
+        # version of the edge equation.
+        log_sum = 0
+
+        # Iterate through edge embeddings
+        for tet, perm in edge.embeddings():
+
+            shape = _shape_for_edge_embedding(tet, perm)
+
+            numerical_shape = NumericalField(shape)
+
+            log_shape = numerical_shape.log()
+
+            # Note that this is true for z in R, R < 0 as well,
+            # but then it would fail for 1 - 1/z or 1 / (1-z)
+
+            if not (log_shape.imag() > 0):
+                raise ShapePositiveImaginaryPartNumericalVerifyError(
+                    numerical_shape)
+
+            # Take logarithm and accumulate
+            log_sum += log_shape
+
+        twoPiI = NumericalField.pi() * NumericalField(2j)
+        
+        if not abs(log_sum - twoPiI) < NumericalField(1e-7):
+            raise EdgeEquationLogLiftNumericalVerifyError(log_sum)
+
+def _shape_for_edge_embedding(tet, perm):
+    """
+    Given an edge embedding, find the shape assignment for it.
+    If the edge embedding flips orientation, apply conjugate inverse.
+    """
+
+    # Get the shape for this edge embedding
+    subsimplex = perm.image(simplex.E01)
+
+    # Figure out the orientation of this tetrahedron
+    # with respect to the edge, apply conjugate inverse
+    # if differ
+    if perm.sign():
+        return 1 / tet.ShapeParameters[subsimplex].conjugate()
+    else:
+        return tet.ShapeParameters[subsimplex]