snappy 3.3__cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

snappy/dev/extended_ptolemy/__init__.py

@@ -0,0 +1,8 @@
+try:
+    import sage.all
+    _within_sage = True
+except:
+    _within_sage = False
+
+if _within_sage:
+    from . import extended

snappy/dev/extended_ptolemy/closed.py

@@ -0,0 +1,106 @@
+"""
+Experimenting with different ways of computing (P)SL(2, C)
+representations of fundamental groups of closed 3-manifolds.
+
+When using PHCPack, for the integral homology spheres below, using two
+variables per tetrahedron is *much* faster than using one (typically
+10 times faster, sometimes more than 100 times faster), and moreover
+seems to gives more useful results.  The Ptolemy approach was
+typically 10 times faster than using the gluing equations with 2
+variables per tet, in one case as much as 60 times faster, though
+there was one relatively small example where using gluing equations
+was twice as fast as using the Ptolemy ones.
+
+"""
+
+import sys, snappy, giac_rur, extended, phc_wrapper, time, gluing
+from sage.all import QQ, PolynomialRing, CC, QQbar, macaulay2
+
+zhs_names = ['m004(-1, 2)', 'm137(-5, 1)', 'm201(1, 4)', 'm275(-4, 3)', 'm372(-3, 2)', 's244(-4, 1)', 's547(3, 4)', 's648(3, 2)', 's727(-5, 3)', 's850(-3, 2)', 's879(1, 2)', 'v2946(-5, 1)', 'v3536(5, 2)', 't08666(-1, 2)', 't10118(-1, 2)', 't11240(5, 2)', 't12072(-11, 1)', 't12721(-1, 3)', 'o9_26088(9, 1)', 'o9_30426(-5, 2)', 'o9_33595(-2, 3)', 'o9_35356(-3, 4)', 'o9_36955(1, 4)', 'o9_38292(-1, 3)', 'o9_39468(5, 4)', 'o9_40388(-4, 1)', 'o9_41178(4, 1)', 'o9_41826(4, 1)', 'o9_42617(3, 2)', 'o9_43446(-4, 3)', 'o9_44109(-4, 3)']
+
+zhs_exs = [snappy.Manifold(name) for name in zhs_names]
+
+def ptolemy_rur(manifold):
+    return extended.rur_for_dehn_filling(manifold)
+
+def ptolemy_sage(manifold):
+    I = extended.ptolemy_ideal_for_filled(manifold)
+    return I.variety(QQbar)
+
+def ptolemy_phc(manifold):
+    I = extended.ptolemy_ideal_for_filled(manifold)
+    return phc_wrapper.find_solutions(I)
+
+def ptolemy_phc_direct(manifold):
+    I = extended.ptolemy_ideal_for_filled(manifold)
+    return phc_wrapper.phcpy_direct(I)
+
+def ptolemy_phc_as_used(manifold):
+    return extended.shapes_of_SL2C_reps_for_filled(manifold, phc_wrapper.phcpy_direct)
+
+def ptolemy_phc_direct_alt(manifold):
+    I = extended.ptolemy_ideal_for_filled(manifold, nonzero_cond=False)
+    return phc_wrapper.phcpy_direct(I)
+
+def ptolemy_nag4m2(manifold):
+    """
+    50-100 times slower than PHCpack even on the simplest examples.
+    """
+    I = extended.ptolemy_ideal_for_filled(manifold)
+    macaulay2('loadPackage "NumericalAlgebraicGeometry"')
+    macaulay2(I.ring())
+    return macaulay2(I.gens()).toList().solveSystem()
+
+def gluing_phc(manifold, vars_per_tet=2):
+    I = gluing.gluing_variety_ideal(manifold, vars_per_tet)
+    sols = phc_wrapper.phcpy_direct(I)
+    output_vars = ['z%d' % i for i in range(manifold.num_tetrahedra())]
+    return [sol for sol in sols
+            if all(abs(sol[z] - 1) > 1e-7 for z in output_vars)]
+
+def hash_sol(sol):
+    zs = sorted([k for k in sol.keys() if k[0] == 'z'], key=lambda x:int(x[1:]))
+    return ';'.join(['%.6f,%.6f' % (sol[z].real, sol[z].imag) for z in zs])
+
+def hash_sols(sols):
+    return {hash_sol(sol) for sol in sols}
+
+def compare_phc(manifold):
+    #start = time.time()
+    #sols = ptolemy_phc_direct(manifold)
+    #print('Ptolemy (direct): %d solutions in %.2f' % (len(sols), time.time() - start))
+    #
+    #start = time.time()
+    #sols = ptolemy_phc_direct_alt(manifold)
+    #print('Ptolemy (direct alt): %d solutions in %.2f' % (len(sols), time.time() - start))
+
+    start = time.time()
+    sols1 = hash_sols(ptolemy_phc_as_used(manifold))
+    print('Ptolemy (as used): %d solutions in %.2f' % (len(sols1), time.time() - start))
+
+    #start = time.time()
+    #sols2 = hash_sols(gluing_phc(manifold, 2))
+    #print('Gluing (direct 2 per tet): %d solutions in  %.2f' % (len(sols2), time.time() - start))
+
+    #start = time.time()
+    #sols3 = hash_sols(gluing_phc(manifold, 1))
+    #print('Gluing (direct 1 per tet): %d solutions in  %.2f' % (len(sols3), time.time() - start))
+
+
+    start = time.time()
+    alt_manifold = manifold.copy()
+    alt_manifold.set_peripheral_curves('fillings')
+    sols4 = hash_sols(ptolemy_phc_as_used(alt_manifold))
+    print('Ptolemy (as used, with merid changed): %d solutions in %.2f' % (len(sols4), time.time() - start))
+
+    #print('Overlap 1 and 2: %d' % len(sols1.intersection(sols2)))
+    #print('Overlap 1 and 3: %d' % len(sols1.intersection(sols3)))
+    #print('Overlap 2 and 3: %d' % len(sols2.intersection(sols3)))
+    print('Overlap 1 and 4: %d' % len(sols1.intersection(sols4)))
+    #print('Common to all  : %d' % len(sols2.intersection(sols3).intersection(sols1)))
+
+
+
+
+
+M = zhs_exs[0]

snappy/dev/extended_ptolemy/complexVolumesClosed.py

@@ -0,0 +1,149 @@
+from snappy.verify.complex_volume.adjust_torsion import (
+    verified_complex_volume_from_lifted_ptolemys)
+from snappy.verify.complex_volume.closed import zero_lifted_holonomy
+
+from snappy.dev.extended_ptolemy import extended
+from snappy.dev.extended_ptolemy import giac_rur
+
+import snappy.snap.t3mlite as t3m
+
+from sage.all import (RealIntervalField, ComplexIntervalField,
+                      RealBallField, ComplexBallField,
+                      RealField,
+                      Integer,
+                      prod, log, exp, pi, xgcd)
+import sage.all
+
+import re
+
+def evaluate_at_roots(numberField, exact_values, precision = 53):
+    """
+    numberField is a sage number field.
+    exact_values a dictionary where values are elements in that number field.
+    precision is desired precision in bits.
+
+    For each embedding of the number field, evaluates the values in the
+    dictionary and produces a new dictionary with the same keys.
+    The new dictionaries are returned in a list.
+    """
+
+    CIF = ComplexIntervalField(precision)
+    return [{ k : v.lift().substitute(root) for k, v in exact_values.items()}
+            for root, multiplicity in numberField.polynomial().roots(CIF)]
+
+def compute_representative_ptolemys_and_full_var_dict(M, precision = 53):
+    """
+    Given a closed manifold (as Dehn-filling on 1-cusped manifold), compute
+    a list of list of dictionaries assigning complex intervals to
+    a subset of ptolemy variables and the full var dictionary to expand these
+    to all variables.
+    (Outer list for components, inner list for Galois conjugates).
+    """
+
+    I, full_var_dict = extended.ptolemy_ideal_for_filled(
+        M, return_full_var_dict = 'data', notation = 'full')
+
+    rur = giac_rur.rational_univariate_representation(I)
+
+    return [
+        evaluate_at_roots(numberField, exact_values, precision)
+        for numberField, exact_values, mult in rur ], full_var_dict
+
+def lift_ptolemy_coordinates(M, solution, full_var_dict):
+    """
+    Given a closed manifold (as Dehn-filling on 1-cusped manifold) and an
+    assignment of subset of ptolemy variables and the full var dict, compute
+    logs for all Ptolemy's.
+    """
+
+    lifted = { str(k) : log(v)
+               for k, v in solution.items()
+               if str(k)[0].islower() }
+
+    m, l = zero_lifted_holonomy(
+        M, lifted['m'], lifted['l'], 2)
+
+    return { k : lifted[name] - (m_count * m + l_count * l)
+             for k, (sign, m_count, l_count, name) in full_var_dict.items()
+             if k[0] == 'c'}
+
+def complex_volumes(M, precision = 53):
+    """
+    Compute all complex volumes from the extended Ptolemy variety for the
+    closed manifold M (given as Dehn-filling on 1-cusped manifold).
+    Note: not every volume might correspond to a representation factoring
+    through the closed manifold. In particular, we get the complex volume
+    of the geometric representation of the cusped manifold.
+    """
+
+    representative_ptolemys, full_var_dict = (
+        compute_representative_ptolemys_and_full_var_dict(M, precision))
+
+    return [
+        [ verified_complex_volume_from_lifted_ptolemys(
+                t3m.Mcomplex(M),
+                lift_ptolemy_coordinates(M, sol, full_var_dict))
+          for sol in galois_conjugates ]
+        for galois_conjugates in representative_ptolemys ]
+
+def has_value(v, values):
+
+    RIF = RealIntervalField(212)
+
+    for value in values:
+        if abs(RIF(v.imag()) - RIF(value.imag())) < RIF(1e-20):
+            r = (RIF(v.real()) - RIF(value.real())) / RIF(pi**2/2)
+
+            is_int, k = r.is_int()
+            if is_int:
+                if abs(r - k) < RIF(1e-20):
+                    return True
+    return False
+
+if __name__ == '__main__':
+    # Use 5_2(1,2) as an example.
+    from snappy import ManifoldHP
+
+    M = ManifoldHP("5_2")
+    M.chern_simons()
+    M.dehn_fill((1,2))
+
+    # Complex volume of geometric representation of 5_2(1,2).
+    # Unverified.
+    geom_cvol = M.complex_volume()
+
+    # This file uses a different convention (simply adding Neumann's
+    # extensions of Roger's dilogarithm to the Abelian cover of C \ {0,1})
+    # from the rest of SnapPy, so convert.
+    geom_cvol = sage.all.I * geom_cvol
+
+    # The complex volumes as verified intervals of the SL(2,C)-representations
+    # detected by the (spun-)triangulation.
+    # Grouped by algebraic component of the extended Ptolemy variety.
+    #
+    # We can only compute it in this file up to multiples of pi^2/2.
+    #
+    # (Note that Neumann's method can compute it up to multiple of pi^2 but
+    # assumes an ordered triangulation. Most census triangulations are not
+    # orderable and would require subdivision).
+    #
+    # The method uses SageMath's giac to compute the rational univariate
+    # representation and evaluates it at the roots of the defining polynomial
+    # using complex intervals.
+    #
+    # It can be accessed from sage (with SnapPy installed) by:
+    # from snappy.dev.extended_ptolemy.complexVolumesClosed import complex_volumes
+    #
+    # Tested with SageMath 9.7 and 10.0.
+    #
+    cvols_by_component = complex_volumes(M, precision = 300)
+
+    print(cvols_by_component)
+
+    # Concatenate the grouped complex volumes to just have a single list.
+    cvols = sum(cvols_by_component, [])
+
+    if not has_value(geom_cvol, cvols):
+        raise RuntimeError(
+            "There is a problem. The complex volume of the geometric "
+            "representation is not included.")

snappy/dev/extended_ptolemy/direct.py

@@ -0,0 +1,42 @@
+import snappy
+from sage.all import QQ, PolynomialRing, matrix, prod
+import giac_rur
+from closed import zhs_exs
+import phc_wrapper
+
+def inverse_word(word):
+    return word.swapcase()[::-1]
+
+def halfes(word):
+    a = len(word)//2
+    return word[:a], inverse_word(word[a:])
+
+def character_variety(group):
+    gens = group.generators()
+    vars = [g + repr(i) for g in gens for i in range(4)]
+    R = PolynomialRing(QQ, vars)
+    mats = {g:matrix(R, [[R(g + '0'), R(g + '1')], [R(g + '2'), R(g + '3')]]) for g in gens}
+    rels = [A.det() - 1 for A in mats.values()]
+    for g in gens:
+        mats[g.upper()] = matrix(R, [[R(g + '3'), -R(g + '1')], [-R(g + '2'), R(g + '0')]])
+
+    def to_mat(word):
+        return prod(mats[w] for w in word)
+
+    for word in group.relators():
+        w0, w1 = halfes(word)
+        diff = to_mat(w0) - to_mat(w1)
+        rels += diff.list()
+
+    rels += [R('a2'), R('a1 - 1'), R('b1')]
+    return R.ideal(rels)
+
+def test_rur(manifold):
+    G = manifold.fundamental_group(True, True, False)
+    I = character_variety(G)
+    return giac_rur.rational_univariate_representation(I)
+
+def test_phc(manifold):
+    G = manifold.fundamental_group(True, True, False)
+    I = character_variety(G)
+    return phc_wrapper.find_solutions(I)