snappy 3.1.1__cp38-cp38-win_amd64.whl → 3.2__cp38-cp38-win_amd64.whl

snappy/upper_halfspace/__init__.py

@@ -1,4 +1,7 @@
-from ..matrix import matrix
+from ..matrix import make_matrix
+from ..sage_helper import _within_sage
+from ..exceptions import InsufficientPrecisionError
+from ..math_basics import is_ComplexIntervalFieldElement
 
 """
 
@@ -36,7 +39,7 @@ complex 2x2-matrix and uses the isomorphism PGL(2,C)=PSL(2,C).
 
 
 def sl2c_inverse(A):
-    return matrix([[A[1,1], -A[0, 1]], [-A[1, 0], A[0, 0]]])
+    return make_matrix([[A[1,1], -A[0, 1]], [-A[1, 0], A[0, 0]]])
 
 
 def psl2c_to_o13(A):
@@ -46,8 +49,10 @@ def psl2c_to_o13(A):
     Python implementation of Moebius_to_O31 in matrix_conversion.c.
     """
 
-    return matrix(
-        [ _o13_matrix_column(A, m)
+    Aadj = _adjoint(A)
+
+    return make_matrix(
+        [ _o13_matrix_column(A, m, Aadj)
           for m in _basis_vectors_sl2c(A.base_ring()) ]).transpose()
 
 
@@ -59,27 +64,83 @@ def pgl2c_to_o13(m):
     """
     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.
 
-def _basis_vectors_sl2c(CF):
-    return [ matrix([[ 1 , 0 ],
-                     [ 0, 1 ]], ring=CF),
-             matrix([[ 1 , 0 ],
-                     [ 0 ,-1 ]], ring=CF),
-             matrix([[ 0 , 1 ],
-                     [ 1 , 0 ]], ring=CF),
-             matrix([[ 0 , 1j],
-                     [-1j, 0 ]], ring=CF) ]
+    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 matrix([[ m[0][0].conjugate(), m[1][0].conjugate()],
-                   [ m[0][1].conjugate(), m[1][1].conjugate()]])
+    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):
-    fAmj = A * m * _adjoint(A)
+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/verify/__init__.py

@@ -1,16 +1,12 @@
 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

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

@@ -1,15 +1,15 @@
 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
 
@@ -26,7 +26,7 @@ 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
 
 
@@ -90,7 +90,7 @@ def interval_checked_canonical_triangulation(M, bits_prec=None):
     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
@@ -171,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:
@@ -204,7 +204,7 @@ def exactly_checked_canonical_retriangulation(M, bits_prec, degree):
             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.
@@ -221,31 +221,34 @@ def exactly_checked_canonical_retriangulation(M, bits_prec, degree):
     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):
     """
@@ -253,23 +256,28 @@ 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))
@@ -317,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::
 
@@ -365,7 +370,11 @@ 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
@@ -374,6 +383,8 @@ def verified_canonical_retriangulation(
 
     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
@@ -391,6 +402,8 @@ def verified_canonical_retriangulation(
                 exceptions.TiltProvenPositiveNumericalVerifyError,
                 exceptions.EdgeEquationExactVerifyError) as e:
 
+            err = e
+
             # These three exceptions are probably raised due to the
             # SnapPea kernel failures:
             # - flat tetrahedra in the proto-canonical triangulation
@@ -436,50 +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:
@@ -489,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):
@@ -509,13 +517,13 @@ 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'),

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

snappy/verify/complex_volume/closed.py

@@ -1,21 +1,21 @@
 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
-    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']
 
-
 def _compute_holonomy(manifold, shapes):
     """
     Computes the holonomy for the peripheral curves for the given 1-cusped
@@ -52,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
@@ -68,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
@@ -116,7 +116,7 @@ def verified_complex_volume_closed_torsion(manifold, bits_prec=None):
         '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
@@ -128,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
@@ -165,4 +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/cusped.py

@@ -1,13 +1,13 @@
 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']
 
@@ -32,7 +32,7 @@ def verified_complex_volume_cusped_torsion(manifold, bits_prec=None):
         '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,
@@ -53,4 +53,4 @@ def verified_complex_volume_cusped_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/extended_bloch.py

@@ -1,11 +1,8 @@
 from ...sage_helper import _within_sage, sage_method
 
 if _within_sage:
-    from sage.all import (ComplexBallField,
-                          RealField,
-                          Integer, exp, pi)
-
-    import sage.all
+    from sage.symbolic.constants import pi
+    from ...sage_helper import I, Integer, RealField, ComplexBallField, exp
 
 
 @sage_method
@@ -106,8 +103,8 @@ 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
     #
@@ -143,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)

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

@@ -1,5 +1,5 @@
+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']

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]