snappy 3.2__cp310-cp310-macosx_10_12_x86_64.whl

snappy/verify/complex_volume/closed.py

@@ -0,0 +1,168 @@
+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.symbolic.constants import pi
+    from ...sage_helper import I, xgcd
+
+from .. import hyperbolicity
+
+from .adjust_torsion import *
+from .compute_ptolemys import *
+
+__all__ = ['verified_complex_volume_closed_torsion']
+
+def _compute_holonomy(manifold, shapes):
+    """
+    Computes the holonomy for the peripheral curves for the given 1-cusped
+    manifold and shape intervals.
+    """
+
+    # Compute z', z''
+    zp = [ (1 / (1 - z)) for z in shapes ]
+    zpp = [ ((z - 1) / z) for z in shapes ]
+
+    # 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 ]
+
+    # Unfill to get both the meridian and longitude gluing equation
+    trig = manifold.without_hyperbolic_structure()
+    trig.dehn_fill((0,0))
+    peripheral_eqns = trig.gluing_equations()[-2:]
+
+    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):
+    """
+    Given a closed manifold and any log of the holonomy of the meridian and
+    longitude, adjust logs by multiplies of f pi i such that the peripheral
+    curves goes to 0.
+    """
+
+    CIF = m.parent()
+    RIF = CIF.real_field()
+    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'])
+
+    # Compute what the peripheral curves goes to right now
+    p_interval = (m_fill * m + l_fill * l).imag() / multiple_of_pi
+    is_int, p = p_interval.is_int()
+
+    if not is_int:
+        raise Exception(
+            "Expected multiple of %d * pi * i (increase precision?)" % f)
+
+    if p == 0:
+        # Nothing to do
+        return m, l
+
+    # Compute by what multiple of 2 pi i to adjust
+    g, a, b = xgcd(m_fill, l_fill)
+    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
+    is_int, p = p_interval.is_int()
+
+    if not is_int:
+        raise Exception(
+            "Expected multiple of %d * pi * i (increase precision?)" % f)
+
+    if p != 0:
+        # Nothing to do
+        raise Exception("Expected 0")
+
+    return m, l
+
+
+@sage_method
+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 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 or SnapPy.ManifoldHP, respectively, will be used.
+    """
+
+    if manifold.num_cusps() != 1:
+        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 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)
+
+    # Check it is a valid hyperbolic structure
+    hyperbolicity.check_logarithmic_gluing_equations_and_positively_oriented_tets(
+        manifold, shapes)
+
+    # Compute holonomy
+    m_holonomy, l_holonomy = _compute_holonomy(manifold, shapes)
+
+    # Compute 1-cocycle in H^1(boundary; Z)
+    m_star, l_star = peripheral.peripheral_cohomology_basis(manifold)
+
+    # Keys for the dual edges in cusp triangulation
+    cusp_dual_edges = [ (i, F, V)
+             for i in range(manifold.num_tetrahedra())
+             for F in simplex.TwoSubsimplices
+             for V in simplex.ZeroSubsimplices
+             if F & V ]
+
+    # Compute 1-cocycle in C^1(boundary; C^*) matching the holonomy
+    one_cocycle = {
+        k : 1 / (m_holonomy ** m_star[k] * l_holonomy ** l_star[k])
+        for k in cusp_dual_edges }
+
+    # Compute cusp cross section (for computation of complex volume,
+    # choices such as cusp size don't matter).
+    c = ComplexCuspCrossSection.fromManifoldAndShapes(
+        manifold, shapes, one_cocycle)
+
+    # Lift holonomy from C^* to C such that it is zero on the
+    # curve we fill along
+    m_lifted_holonomy, l_lifted_holonomy = zero_lifted_holonomy(
+        manifold, m_holonomy.log() / 2, l_holonomy.log() / 2, 1)
+
+    # Compute corresponding 1-cocycle in C^1(boundary; C)
+    lifted_one_cocycle = {
+        k: m_lifted_holonomy * m_star[k] + l_lifted_holonomy * l_star[k]
+        for k in cusp_dual_edges }
+
+    # Compute the lifted Ptolemy coordinates from cross section
+    lifted_ptolemys = lifted_ptolemys_from_cross_section(
+        c, lifted_one_cocycle)
+
+    # Compute the complex volume from the Ptolemy coordinates
+    complex_volume = verified_complex_volume_from_lifted_ptolemys(
+        c.mcomplex, lifted_ptolemys)
+
+    # When using the dilogarithm, the Chern-Simons is the real part.
+    # 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) / I

snappy/verify/complex_volume/compute_ptolemys.py

@@ -0,0 +1,90 @@
+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,
+        (edge & 4) >> 2,
+        (edge & 2) >> 1,
+        (edge & 1),
+        tet_index)
+
+
+def lifted_ptolemys_from_cross_section(cusp_cross_section,
+                                       lifted_one_cocycle=None):
+    """
+    Given a cusp cross section, compute lifted Ptolemy coordinates
+    (i.e., logarithms of the Ptolemy coordinates) returned as a dictionary
+    (e.g., the key for the Ptolemy coordinate for the edge from
+    vertex 0 to vertex 3 or simplex 4 is c_1001_4).
+
+    For complete cusp cross sections (where no lifted_one_cocycle is
+    necessary), we use Zickert's algorithm (Christian Zickert, The
+    volume and Chern-Simons invariant of a representation, Duke
+    Math. J. 150 no. 3 (2009) 489-532, math.GT/0710.2049). In this
+    case, all values for keys corresponding to the same edge in the
+    triangulation are guaranteed to be the same.
+
+    For the incomplete cusp cross sections, a lifted_one_cocycle
+    needs to be given. This cocycle is a lift of the cocycle one_cocycle
+    given to ComplexCuspCrossSection.fromManifoldAndShapes.
+    More precisely, lifted_one_cocycle is in C^1(boundary M; C) and
+    needs to map to one_cocycle in C^1(boundary M; C^*).
+    """
+
+    result = {}
+
+    some_tet = cusp_cross_section.mcomplex.Tetrahedra[0]
+    some_z = some_tet.ShapeParameters[t3m.E01]
+    CIF = some_z.parent()
+
+    # Compute the (lifted) Ptolemy coordinate for each edge of the
+    # triangulation only once
+    for edge in cusp_cross_section.mcomplex.Edges:
+        # Look at each way the triangulation's edge appears as edge
+        # 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)
+            # The edge in the tetrahedron
+            e = v0 | v1
+            # Face adjacent to the edge
+            face = e | v2
+
+            # Compute Ptolemy coordinate only once and use it
+            # for all other representatives of the triangulation's
+            # edge. Or use one_cocycle to transfer Ptolemy coordinate
+            # to other representatives.
+            if i == 0:
+                # Near one of the two ends of the edge of the tetrahedron
+                # the tetrahedron's face intersect the cusp neighborhood
+                # in an edge of the cusp cross section.
+                # Get the complex lengths of the two edges in the
+                # cusp cross section.
+                l1 = CIF(tet.horotriangles[v0].lengths[face])
+                l2 = CIF(tet.horotriangles[v1].lengths[face])
+
+                # Zickert's result: the Ptolemy coordinate is the
+                # inverse of the square root of the product of those two
+                # edge lengths.
+                #
+                # The choice of square root (and logarithm) does not
+                # matter as long as it is only done once per edge of
+                # the triangulation.
+                ptolemy = 1 / (l1 * l2).sqrt()
+                ptolemy = ptolemy.log()
+
+            elif lifted_one_cocycle:
+                # Use cocycle to compute for different representative
+                # edges
+                ptolemy -= lifted_one_cocycle[tet.Index, face, v0]
+                ptolemy -= lifted_one_cocycle[tet.Index, face, v1]
+
+            # Save Ptolemy coordinate in dictionary
+            result[_ptolemy_coordinate_key(tet.Index, e)] = ptolemy
+
+    return result

snappy/verify/complex_volume/cusped.py

@@ -0,0 +1,56 @@
+from ...sage_helper import _within_sage, sage_method
+
+if _within_sage:
+    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 *
+
+__all__ = ['verified_complex_volume_cusped_torsion']
+
+
+@sage_method
+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
+    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.
+
+    If bits_prec is unspecified, the default precision of
+    SnapPy.Manifold, respectively, SnapPy.ManifoldHP will be used.
+    """
+
+    # Compute tetrahedra shapes to arbitrary precision.
+    shapes = manifold.tetrahedra_shapes(
+        'rect', bits_prec=bits_prec, intervals=True)
+
+    # Check it is a valid hyperbolic structure
+    hyperbolicity.check_logarithmic_gluing_equations_and_positively_oriented_tets(
+        manifold, shapes)
+
+    # Compute cusp cross section. For computation of complex volume,
+    # the size does not matter.
+    c = ComplexCuspCrossSection.fromManifoldAndShapes(manifold, shapes)
+
+    # Compute lifted Ptolemy coordinates: for each edge of the
+    # triangulation, a logarithm of the Ptolemy coordinate is computed
+    # once. Result is a dictionary.
+    lifted_ptolemys = lifted_ptolemys_from_cross_section(c)
+
+    # Compute the complex volume from the Ptolemy coordinates
+    complex_volume = verified_complex_volume_from_lifted_ptolemys(
+        c.mcomplex, lifted_ptolemys)
+
+    # When using the dilogarithm, the Chern-Simons is the real part.
+    # 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) / I

snappy/verify/complex_volume/extended_bloch.py

@@ -0,0 +1,201 @@
+from ...sage_helper import _within_sage, sage_method
+
+if _within_sage:
+    from sage.symbolic.constants import pi
+    from ...sage_helper import I, Integer, RealField, ComplexBallField, exp
+
+
+@sage_method
+def compute_z_and_parities_from_flattening_w0_w1(w0, w1):
+    """
+    Given a pair (w0, w1) with +- exp(w0) +- exp(-w1) = 1, compute (z, p, q)
+    such that z = (-1)^p * exp(w0) and 1/(1-z) = (-1)^q exp(w1)
+    where p, q in {0,1}.
+    """
+
+    e0 = exp( w0)
+    e1 = exp(-w1)
+
+    l = [ (((-1) ** p) * e0, p, q)
+          for p in [ 0, 1]
+          for q in [ 0, 1]
+          if Integer(1) in ((-1) ** p) * e0 + ((-1) ** q) * e1 ]
+    if not len(l) == 1:
+        raise Exception("Bad flattening %s %s %s" % (w0, w1, len(l)))
+
+    return l[0]
+
+
+@sage_method
+def compute_p_from_w_and_parity(w, parity):
+    """
+    Compute p such that w - p * pi * i should have imaginary part between
+    -pi and pi and p has the same parity as the given value for parity
+    (the given value is supposed to be 0 or 1).
+
+    Note that this computation is not verified.
+    """
+
+    RF = RealField(w.parent().precision())
+    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):
+    """
+    Compute dilogarithm using complex ball field.
+    The dilogarithm isn't implemented for ComplexIntervalField itself, so
+    we use ComplexBallField. Note that ComplexBallField is conservative
+    about branch cuts. For Li_2(2+-i * epsilon), it returns the interval
+    containing both Li_2(2+i * epsilon) and Li_2(2-i * epsilon).
+
+    Thus, we need to avoid calling this function with a value near real numbers
+    greater 1.
+    """
+
+    CIF = z.parent()
+    CBF = ComplexBallField(CIF.precision())
+
+    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):
+    """
+    Given a flattening w0, w1 such that +- exp(w0) +- exp(-w1) = 1, compute
+    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)
+
+    # Compute [z; p, q]
+    z, p, q = compute_z_p_q_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 * 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
+    #
+    # where
+    #     term1 = log(z) * log(1-z)
+    #     term2 = pi * i * (p * log(1-z) + q * log(z))
+    #
+    # Using Li_2(z) + Li_1(1-z) = pi^2/6 - log(z) * log(1-z), we also get
+    #
+    # (2) R(z; p, q) = - Li_2(1-z) + (-term1 + term2) / 2
+    #
+    # We use (1) when Re(z) < 1/2 and (2) otherwise.
+    #
+    # Note that if we use (1), we do not rely on the value computed for log(z)
+    # to have imaginary part between -pi and pi (because p was not computed
+    # such that we have this property). More precisely, if we add 2 to p, the
+    # value computed for log(z) changes by -2 * pi * i, so term1 changes by
+    # -2 * pi * i * log(1-z) but this is compensated by the change in term2.
+    # We do, however, need to check that the value of log(1-z) has imaginary
+    # part between -pi and pi. Since We have Re(z) < 1/2, we indeed expect that
+    # the imaginary part is between -pi/2 and pi/2 and can check the stronger
+    # condition that the imaginary part is between -2 and 2.
+    # We need to make sure that Li_2(z) is evaluated correctly. We always
+    # want to take the main branch. If z is close to the branch cut ([1,inf)),
+    # the choice is ambiguous but we are safe since my_dilog would
+    # conservatively return the large interval containing both branch choices.
+    # Note that we should always be able to avoid this by increasing bits_prec
+    # since we only use (1) if the interval for z is centered to the left of
+    # the line with real part 1/2.
+    #
+    # Similar considerations apply to (2) used when Re(z) > 1/2.
+
+    term1 = logZ * logOneMinusZ
+    term2 = my_pi * I * (p * logOneMinusZ + q * logZ)
+
+    if z.real().center() < 0.5:
+        # Check that we can apply equation (1)
+        if not is_imaginary_part_bounded(logOneMinusZ, 2):
+            raise Exception("Problem with computing Neumanns dilog using (1)",
+                            z, logOneMinusZ)
+
+        return ( term1 + term2) / 2 + my_dilog(z) - my_pi * my_pi / 6
+    else:
+        # Check that we can apply equation (2)
+        if not is_imaginary_part_bounded(logZ, 2):
+            raise Exception("Problem with computing Neumanns dilog using (2)",
+                            z, logZ)
+
+        return (-term1 + term2) / 2 - my_dilog(1 - z)
+
+
+@sage_method
+def compute_complex_volume_of_simplex_from_lifted_ptolemys(index, ptolemys):
+    """
+    Given lifted Ptolemy coordinates for a triangulation (as dictionary),
+    compute the complex volume contribution by the simplex with given index.
+    """
+
+    # The six Ptolemy coordinates for the given simplex
+    c_1100 = ptolemys['c_1100_%d' % index]
+    c_1010 = ptolemys['c_1010_%d' % index]
+    c_1001 = ptolemys['c_1001_%d' % index]
+    c_0110 = ptolemys['c_0110_%d' % index]
+    c_0101 = ptolemys['c_0101_%d' % index]
+    c_0011 = ptolemys['c_0011_%d' % index]
+
+    # Compute Neumann's flattening (w0, w1) from Ptolemy coordinates
+    w0 = c_1010 + c_0101 - c_1001 - c_0110
+    w1 = c_1001 + c_0110 - c_1100 - c_0011
+
+    # 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):
+    """
+    Given lifted Ptolemy coordinates for a triangulation (as dictionary)
+    and the number of tetrahedra, compute the complex volume (where
+    the real part is the Chern-Simons and the imaginary part is the
+    volume).
+
+    This sums of the dilogs across tetrahedra without adjusting for the
+    fact that the triangulation might not be ordered.
+    Thus, the Chern-Simons is correct only up to multiples of pi^2/6.
+    """
+
+    return sum(
+        [ compute_complex_volume_of_simplex_from_lifted_ptolemys(
+                index, ptolemys)
+          for index in range(num_tetrahedra) ])

snappy/verify/cusp_translations.py

@@ -0,0 +1,85 @@
+from ..geometric_structure.cusp_neighborhood.complex_cusp_cross_section import ComplexCuspCrossSection
+from .shapes import compute_hyperbolic_shapes
+
+__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):
+
+    shapes = compute_hyperbolic_shapes(
+        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(manifold, shapes)
+
+    if areas:
+        RF = shapes[0].real().parent()
+        # Convert given areas to elements in real (interval) field and then
+        # scale cusps to have that given area.
+        #
+        # These areas are just used as a hint to initialize the computation
+        # of cusp neighborhoods that are disjoint. ensure_disjoint will
+        # scale the cusps further down so that it is verified they are
+        # disjoint. In particular, it is ok that the given areas might be
+        # of a lower precision type or two use the number and turn it
+        # into an interval of length 0.
+        #
+        # 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.
+            c.ensure_std_form()
+    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)
+
+    # Note: the only code path avoiding ensure_std_form is through calling
+    # all_translations on a CuspNeighborhood with verified = False,
+    # see comment in cusp_translations_for_neighborhood
+
+    # Scale down cusps neighborhoods further to make sure that they are
+    # disjoint.
+    c.ensure_disjoint_on_edges()
+
+    # The result
+    return c.all_normalized_translations()
+
+
+def cusp_translations_for_neighborhood(neighborhood,
+                                       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()) ]
+
+    # If we want verified results, do not rely on anything reported from
+    # the kernel, the areas are only used as hint. The cusps could be scaled
+    # down further to ensure the cusps neighborhoods are in standard form.
+
+    # If we don't want verified results, we set check_std_form to False to
+    # get high-precision results consistent with the translations reported
+    # by the kernel.
+    # This is safe under the assumption that the kernel has found a correct
+    # proto-canonical triangulation for the CuspNeighborhood. The kernel
+    # 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)

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]