snappy 3.2__cp313-cp313-macosx_11_0_arm64.whl

snappy/dev/extended_ptolemy/phc_wrapper.py

@@ -0,0 +1,220 @@
+"""
+There are two Python interfaces to PHCpack, but both require
+compiling from the Ada source, which is often a pain.
+
+This file implements a simple wrapper for the command-line version of
+PHCpack.
+
+>>> from sage.all import RealField, ComplexField, QQ, PolynomialRing
+>>> R = PolynomialRing(QQ, ['x', 'y', 'e'])
+>>> I = R.ideal([R('x^2 + y^2 - 1'), R('(x -  1/2)^2 + y^2 - 1'), R('x*y*e - 1')])
+>>> I.dimension()
+0
+>>> abs(find_solutions(I, 2)[0]['coors']['y'])
+0.9682458365518542212948163499456
+
+However, the black-box solver applies more root-counts than just using
+CyPHC, sometimes slowing things down by a factor of 10 or more.
+Moreover, CyPHC uses root counts geared toward finding solutions with
+all coordinates non-zero, which is what we often want anyway.
+"""
+
+import re, sys, os, tempfile, json
+replacements = [('i', 3*'xX'), ('I',  3*'Xx'), ('e', 3*'yY'), ('E', 3*'Yy'),
+                ('t', 3*'Mm'), ('m', 3*'Mm')]
+
+def remove_forbidden(poly_str):
+    """
+    PHCpack doesn't allow variables with {i, I, e, E} in the name.
+    Also, with the phcpy interface, it uses "m" for the multiplicity
+    and "t" for the homotopy parameter.
+    """
+    for bad, replacement in replacements:
+        poly_str = poly_str.replace(bad, replacement)
+    return poly_str
+
+def restore_forbidden(var_str):
+    for bad, replacement in replacements:
+        var_str = var_str.replace(replacement, bad)
+    return var_str
+
+def ideal_to_file(ideal, filename):
+    outfile = open(filename, 'w')
+    polys = ideal.gens()
+    outfile.write(r'%d\n' % len(polys))
+    for p in polys:
+        outfile.write('   ' + remove_forbidden(repr(p)) + r';\n')
+    outfile.close()
+
+def parse_file(filename, prec=53):
+    from sage.all import RealField, ComplexField
+    RR = RealField(prec)
+    CC = ComplexField(prec)
+    data = open(filename).read()
+    open('polys.txt', 'w').write(data)
+    data = data.split('THE SOLUTIONS')[-1]
+    data = re.subn('[*]{3,}', '', data)[0]
+    ans = []
+    solutions = re.findall(r'(solution \d+ : \s* start residual .*?) ==', data, re.DOTALL)
+    for sol in solutions:
+        kind = sol.split('=')[-1].strip()
+        if kind == 'no solution':
+            continue
+        mult = int(re.search(r'^m : (\d+)', sol, re.MULTILINE).group(1))
+        err = float(re.search(r'== err :\s+(.*?)\s+= ', sol).group(1))
+        coors = re.findall(r'^ (.*) :\s+(\S*)\s+(\S*)', sol, re.MULTILINE)
+        if kind.startswith('real'):
+            coors = {restore_forbidden(var):RR(real) for var, real, imag in coors}
+            ans.append({'kind':'real', 'mult':mult, 'err':err, 'coors':coors})
+        elif kind.startswith('complex'):
+            coors = {restore_forbidden(var):CC(RR(real), RR(imag)) for var, real, imag in coors}
+            ans.append({'kind':'complex', 'mult':mult, 'err':err, 'coors':coors})
+
+    num_real = int(re.search(r'Number of real solutions\s+:\s(.*).', data).group(1))
+    num_complex = int(re.search(r'Number of complex solutions\s+:\s(.*).', data).group(1))
+    kinds = [sol['kind'] for sol in ans]
+    assert kinds.count('real') == num_real
+    assert kinds.count('complex') == num_complex
+    return ans
+
+def find_solutions(ideal, doubles=1):
+    assert doubles in [1, 2, 4]
+    prec = 53*doubles
+    tmpdir = tempfile.mkdtemp()
+    infile = tmpdir + os.sep + 'polys.txt'
+    outfile = tmpdir + os.sep + 'out.txt'
+    ideal_to_file(ideal, tmpdir + os.sep + 'polys.txt')
+    flag = {1:'-b', 2:'-b2', 4:'-b4'}[doubles]
+    os.system('phc ' + flag + ' ' + infile + ' ' + outfile)
+    ans = parse_file(outfile, prec)
+    os.system('rm -rf tmpdir')
+    return ans
+
+
+def clean_complex(z, epsilon=1e-14):
+    r, i = abs(z.real), abs(z.imag)
+    if r < epsilon and i < epsilon:
+        ans = 0.0
+    elif r < epsilon:
+        ans = z.imag*1j
+    elif i < epsilon:
+        ans = z.real
+    else:
+        ans = z
+    assert abs(z - ans) < 1.5*epsilon
+    return ans
+
+def sol_to_dict(sol, vars):
+    ans = {v:clean_complex(p) for v, p in zip(vars, sol.point)}
+    for attr in ['err', 'rco', 'res', 'mult']:
+        ans[attr] = getattr(sol, attr)
+    return ans
+
+def serialize_sol_dict(sol):
+    sol = sol.copy()
+    for key, val in sol.items():
+        if isinstance(val, complex):
+            sol[key] = (val.real, val.imag)
+    return sol
+
+def phc_direct_base(var_names, eqns_as_strings):
+    import cyphc
+    mangled_vars = [remove_forbidden(v) for v in var_names]
+    R = cyphc.PolyRing(mangled_vars)
+    polys = [cyphc.PHCPoly(R, remove_forbidden(eqn)) for eqn in eqns_as_strings]
+    system = cyphc.PHCSystem(R, polys)
+    sols = system.solution_list()
+    return [sol_to_dict(sol, var_names) for sol in sols]
+
+def phc_direct(ideal):
+    vars = ideal.ring().variable_names()
+    eqns = [repr(p) for p in ideal.gens()]
+    return phc_direct_base(vars, eqns)
+
+def phcpy_direct_base(var_names, eqns_as_strings,
+                      tasks=0, precision='d', tolerance=1e-6):
+
+    """
+    Use the official PHCPack Python interface to find solutions to the
+    given equations. To duplicate the behavior of CyPHC, we filter out
+    any solutions with a coordinate too close to zero or infinity, as
+    determined by the tolerance parameter.  It's not clear to me why
+    this is needed since I believe phcpy is calling the Laurent
+    polynomial version of it's solver, which presumably assumes this,
+    but...
+    """
+
+    import phcpy
+    polys = [remove_forbidden(eqn) + ';' for eqn in eqns_as_strings]
+    sols = phcpy.solver.solve(polys, verbose=False, tasks=tasks,
+                             precision=precision, checkin=True)
+    ans = []
+    for sol in sols:
+        if sol.find('NaN******') > -1:
+            continue
+        sol = phcpy.solutions.strsol2dict(sol)
+        good_sol = True
+        sol['mult'] = sol['m']
+        sol.pop('m')
+        sol['t_hom_val'] = sol['t']
+        sol.pop('t')
+        for v in var_names:
+            w = remove_forbidden(v)
+            if v != w:
+                sol[v] = sol[w]
+                sol.pop(w)
+            sol[v] = clean_complex(sol[v])
+            size = abs(sol[v])
+            if size < tolerance or size > 1.0/tolerance:
+                good_sol = False
+        if good_sol:
+            ans.append(sol)
+    return ans
+
+def phcpy_direct(ideal, tasks=0, precision='d'):
+    vars = ideal.ring().variable_names()
+    eqns = [repr(p) for p in ideal.gens()]
+    return phcpy_direct_base(vars, eqns, tasks=tasks, precision=precision)
+
+def direct_hack(backend, ideal, **kwargs):
+    """
+    To avoid memory leaks and random PARI crashes, runs CyPHC
+    in a separate subprocess.
+    """
+    vars = ideal.ring().variable_names()
+    polys = [repr(eqn) for eqn in ideal.gens()]
+
+    data = {'backend':backend, 'vars':vars, 'polys':polys, 'kwargs':kwargs}
+    problem_data = json.dumps(data).encode('base64').replace(r'\n', '')
+    ans_data = os.popen('sage -python ' + __file__ + ' ' + problem_data).read()
+    ans_data = re.sub(r'PHCv.*? released .*? works!\n', '',  ans_data)
+    if len(ans_data):
+        ans = json.loads(ans_data)
+        for sol in ans:
+            for key, val in sol.items():
+                if isinstance(val, list):
+                    sol[key] = complex(*val)
+    else:
+        ans = []
+    return ans
+
+def phc_direct_hack(ideal):
+    return direct_hack('cyphc', ideal)
+
+def phcpy_direct_hack(ideal, **kwargs):
+    return direct_hack('phcpy', ideal, **kwargs)
+
+def execute_hack():
+    data = json.loads(sys.argv[1].decode('base64'))
+    if data['backend'] == 'cyphc':
+        solver = phc_direct_base
+    elif data['backend'] == 'phcpy':
+        solver = phcpy_direct_base
+    else:
+        raise ValueError('nonexistent backend specified')
+    sols = [serialize_sol_dict(sol) for sol in
+            solver(data['vars'], data['polys'], **data['kwargs'])]
+    sys.stdout.write(json.dumps(sols))
+
+if __name__ == '__main__':
+    execute_hack()

snappy/dev/extended_ptolemy/printMatrices.py

@@ -0,0 +1,70 @@
+from snappy.dev.extended_ptolemy import extended
+from snappy.dev.extended_ptolemy import giac_rur
+from snappy.dev.extended_ptolemy.complexVolumesClosed import evaluate_at_roots
+from snappy.ptolemy.coordinates import PtolemyCoordinates, CrossRatios
+
+def compute_ptolemy_from_solution(I, solution, dict_value):
+    sign, m_count, l_count, name = dict_value
+
+    R = I.ring()
+
+    m = solution[R('M')] if m_count >= 0 else solution[R('m')]
+    l = solution[R('L')] if l_count >= 0 else solution[R('l')]
+
+    return sign * m ** abs(m_count) * l ** abs(l_count) * solution[R(name)]
+
+def extended_ptolemy_solutions(M):
+    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 [
+        (nf, { key : compute_ptolemy_from_solution(I, solution, value)
+               for key, value in full_var_dict.items() },
+         multiplicity)
+        for nf, solution, multiplicity in rur ]
+
+def ptolemy_coordinates(M):
+    return [
+        PtolemyCoordinates(d, is_numerical = False,
+                           manifold_thunk = lambda : M)
+        for nf, d, multiplicity
+        in extended_ptolemy_solutions(M) ]
+
+def cross_ratios(M):
+    return [
+        ptolemys.cross_ratios()
+        for ptolemys
+        in ptolemy_coordinates(M) ]
+
+
+if __name__ == '__main__':
+    from snappy import Manifold
+    import sys
+
+    if len(sys.argv) != 2:
+        print("Usage: sage -python printMatrices.py CLOSED_MFD")
+        print()
+        print('Example: sage -python printMatrices.py "m004(2,3)"')
+        sys.exit(1)
+
+    M = Manifold(sys.argv[1])
+    G = M.fundamental_group()
+    list_z = cross_ratios(M)
+    for i, z in enumerate(list_z):
+        print("Solution %d:" % i)
+        nf = z['z_0000_0'].parent()
+        print("    Number field:", nf.defining_polynomial())
+        print("    Exact values:")
+        for g in G.generators():
+            print("        Generator %s:" % g)
+            print(z.evaluate_word(g, G))
+
+        for z_numerical in evaluate_at_roots(nf, z, precision = 100):
+            print("    Numerical values:")
+            d = CrossRatios(z_numerical, manifold_thunk = lambda : M)
+            
+            for g in G.generators():
+                print("        Generator %s:" % g)
+                print(d.evaluate_word(g, G))

snappy/dev/vericlosed/__init__.py

@@ -0,0 +1 @@
+from .computeVerifiedHyperbolicStructure import *

snappy/dev/vericlosed/computeApproxHyperbolicStructureNew.py

@@ -0,0 +1,159 @@
+from .hyperbolicStructure import *
+from .verificationError import *
+
+from sage.all import RDF, pi, matrix, block_matrix, vector
+
+__all__ = ['compute_approx_hyperbolic_structure_new']
+
+# Constants
+
+_singular_epsilon = RDF(1e-4)
+_theta_thres = RDF(2.6)
+_theta_max = RDF(2.5)
+_two_pi = RDF(2*pi)
+_start_edge_param = RDF(-2)
+
+_iteration_stop = RDF(1e-12)
+
+def _pseudo_inverse(m, verbose = False):
+    global _singular_epsilon
+
+    u, d, v = m.SVD()
+
+    dims = d.dimensions()
+    dQuasiInverse = matrix(RDF, dims[1], dims[0])
+
+    rank = 0
+
+    for i in range(min(dims)):
+        if abs(d[i,i]) > _singular_epsilon:
+            dQuasiInverse[i,i] = 1.0 / d[i,i]
+            rank += 1
+            
+    if verbose:
+        print("Rank: %d" % rank)
+
+    return v * dQuasiInverse * u.transpose()
+
+def _large_angle_penalties_and_derivatives(hyperbolicStructure,
+                                           verbose = False):
+    global _theta_thres
+    global _theta_max
+
+    penalties = []
+    penalty_derivatives = []
+    
+    number_large_angles = 0
+    max_angle = 0
+
+    for tet, m in enumerate(hyperbolicStructure.dihedral_angles):
+        for j in range(1, 4):
+            for i in range(0, j):
+                if m[i][j] > _theta_thres:
+                    penalties.append(m[i][j] - _theta_max)
+                    penalty_derivatives.append(
+                        hyperbolicStructure.derivative_of_single_dihedral_angle(
+                            tet, i, j))
+
+                    number_large_angles += 1
+                    if m[i][j] > max_angle:
+                        max_angle = m[i][j]
+
+    if verbose:
+        print("Number of large angles: %d, Maximum: %f" % (
+            number_large_angles, max_angle))
+
+    return penalties, penalty_derivatives
+
+def _compute_errors_with_norm(hyperbolicStructure):
+    global _two_pi
+    errors = [ angle - _two_pi for angle in hyperbolicStructure.angle_sums ]
+    return errors, vector(errors).norm()
+
+def _adaptive_newton_step(hyperbolicStructure, errors_with_norm, verbose = False):
+    
+    errors, errors_norm = errors_with_norm
+
+    num_edges = len(hyperbolicStructure.mcomplex.Edges)
+    
+    penalties, penalty_derivative = _large_angle_penalties_and_derivatives(
+        hyperbolicStructure, verbose = verbose)
+    
+    all_errors = vector(errors + penalties)
+    
+    jacobian = hyperbolicStructure.jacobian()
+    penalty_derivative_matrix = matrix(
+        RDF, penalty_derivative, ncols = num_edges)
+    
+    m = block_matrix(
+        [[jacobian],
+         [penalty_derivative_matrix]])
+    
+    mInv = _pseudo_inverse(m, verbose = verbose)
+    mInvErrs = mInv * all_errors
+
+    for i in range(14):
+        step_size = RDF(0.5) ** i
+
+        new_edge_params = list(
+            vector(hyperbolicStructure.edge_lengths) - step_size * mInvErrs)
+        try:
+            newHyperbolicStructure = HyperbolicStructure(
+                hyperbolicStructure.mcomplex, new_edge_params)
+        except BadDihedralAngleError:
+            continue
+
+        new_errors_with_norm = _compute_errors_with_norm(
+            newHyperbolicStructure)
+
+        if new_errors_with_norm[1] < errors_norm:
+            return (newHyperbolicStructure, 
+                    new_errors_with_norm)
+
+    raise NewtonStepError()
+
+def compute_approx_hyperbolic_structure_new(mcomplex, verbose = False):
+    """
+    Finds unverified hyperbolic structure for an Mcomplex.
+
+    >>> from snappy import Triangulation
+    >>> from snappy.snap.t3mlite import Mcomplex
+    >>> isosig = 'uLLvLALLQPAPAMcbehgilknmkonpoqrqrsttxxuvcaiauxawkkutxhqqw'
+    >>> m = Mcomplex(Triangulation(isosig, remove_finite_vertices = False))
+    >>> h = compute_approx_hyperbolic_structure_new(m)
+    >>> all([ abs(s - _two_pi) < 1e-11 for s in h.angle_sums ])
+    True
+
+    """
+
+    global _start_edge_param
+    global _iteration_stop
+
+    edge_params = [
+        _start_edge_param for edge in mcomplex.Edges ]
+
+    hyperbolicStructure = HyperbolicStructure(
+        mcomplex, edge_params)
+
+    errors_with_norm = _compute_errors_with_norm(hyperbolicStructure)
+
+    for i in range(100):
+        
+        if verbose:
+            print("Iteration: %d" % i)
+
+        hyperbolicStructure, errors_with_norm = (
+            _adaptive_newton_step(
+                hyperbolicStructure, errors_with_norm, verbose = verbose))
+
+        if max([abs(x) for x in errors_with_norm[0]]) < _iteration_stop:
+            return hyperbolicStructure
+
+    raise NewtonMethodConvergenceError()
+
+def _doctest():
+    import doctest
+    doctest.testmod()
+
+if __name__ == '__main__':
+    _doctest()

snappy/dev/vericlosed/computeApproxHyperbolicStructureOrb.py

@@ -0,0 +1,90 @@
+from .parseVertexGramMatrixFile import *
+from .verificationError import *
+
+from .orb import __path__ as orb_path
+
+from snappy.snap.t3mlite import Mcomplex
+
+import subprocess
+import tempfile
+import shutil
+import os
+    
+__all__ = ['compute_approx_hyperbolic_structure_orb']
+
+
+class TmpDir():
+    """
+    To be used in a with statement, creating a temporary
+    directory deleted at the end of the with statement.
+    """
+
+    def __init__(self, delete = True):
+        self.delete = delete
+
+    def __enter__(self):
+        self.path = tempfile.mkdtemp()
+        return self
+
+    def __exit__(self, type, value, traceback):
+        if self.delete:
+            shutil.rmtree(self.path)
+
+def _compute_vertex_gram_matrix_file_orb(triangulation, tmpDir, verbose = False):
+    """
+    Calls Orb to compute an approximate solution to the edge equation
+    for the given snappy.Triangulation (using directory at path tmpDir).
+    """
+
+    # Path for triangulation
+    basename = os.path.join(tmpDir, 'manifold.tri')
+
+    # Save triangulation to disk
+    triangulation.save(basename)
+
+    if verbose:
+        print("Calling orb to find approximate solution on", basename)
+
+    # Find Orb wrapper
+    path = os.path.join(orb_path[0], 'orb_solution_for_snappea_finite_triangulation_mac')
+
+    try:
+        if verbose:
+            stdout = None
+        else:
+            # Redirect output to nirvana
+            stdout = open(os.devnull, 'w')
+
+        # Call Orb
+        ret = subprocess.call([path, basename], stdout = stdout)
+    except OSError as e:
+        raise OrbMissingError(
+            "Seems orb binary %s is missing. Original exception: %s" % (
+                path, e))
+
+    if ret != 0:
+        if ret <= 7:
+            raise OrbSolutionTypeError("Solution type orb found was", ret)
+        raise UnknownOrbFailureError("Exit code", ret)
+
+    # Path of output that Orb produced
+    return basename + '.vgm'
+
+def compute_approx_hyperbolic_structure_orb(triangulation, verbose = False):
+    """
+    Calls Orb to compute an approximate solution to the edge equation
+    for the given snappy.Triangulation.
+
+    The result is a veriClosed.HyperbolicStructure where the edge lengths
+    are in SageMath's RealDoubleField.
+    """
+
+    # Input and output to Orb are in a temporary directory deleted
+    # at the end
+    with TmpDir() as tmp_dir:
+        # Invoke Orb to compute file containing vertex gram matrices
+        vgm_file_path = _compute_vertex_gram_matrix_file_orb(
+            triangulation, tmp_dir.path, verbose = verbose)
+        # Parse the file to obtain hyperbolic structure
+        return compute_approx_hyperbolic_structure_from_vertex_gram_matrix_file(
+            Mcomplex(triangulation), vgm_file_path)

snappy/dev/vericlosed/computeVerifiedHyperbolicStructure.py

@@ -0,0 +1,111 @@
+from .computeApproxHyperbolicStructureNew import *
+from .computeApproxHyperbolicStructureOrb import *
+from .polishApproxHyperbolicStructure import *
+from .krawczykCertifiedEdgeLengthsEngine import *
+from .verifyHyperbolicStructureEngine import *
+from .parseVertexGramMatrixFile import (
+    compute_approx_hyperbolic_structure_from_vertex_gram_matrix_file)
+
+from snappy.snap.t3mlite import Mcomplex
+
+def compute_unverified_hyperbolic_structure(triangulation,
+                                            source = 'new',
+                                            verbose = False):
+
+    """
+    Given a snappy.Triangulation, computes an unverified hyperbolic structure,
+    i.e., an instance of HyperbolicStructure where the edge lengths are in
+    SageMath's RealDoubleField.
+
+    The optional argument source can be:
+       - 'new' to use the new python only implementation
+       - 'orb' to use Orb
+       - the path to a file containing vertex gram matrices as produced by
+         orb_solution_for_snappea_finite_triangulation
+    """
+
+    if source == 'new':
+        return compute_approx_hyperbolic_structure_new(
+            Mcomplex(triangulation),
+            verbose = verbose)
+    elif source == 'orb':
+        return compute_approx_hyperbolic_structure_orb(
+            triangulation)
+    else:
+        return compute_approx_hyperbolic_structure_from_vertex_gram_matrix_file(
+            Mcomplex(triangulation), source)
+    
+def compute_verified_hyperbolic_structure_from_approx_structure(
+            approx_hyperbolic_structure, bits_prec = 53, verbose = False):
+
+    """
+    Computes a verified hyperbolic structure given an instance of
+    HyperbolicStructure where the (unverified) edge lengths are in
+    SageMath's RealDoubleField or RealField.
+    """
+
+    # Step I of the algorithm:
+    approx_hyperbolic_structure.pick_exact_and_var_edges()
+
+    # Use ordinary Newton method before Step II to obtain a higher 
+    # precision solution
+    polished_hyperbolic_structure = polish_approx_hyperbolic_structure(
+        approx_hyperbolic_structure, bits_prec, verbose = verbose)
+    
+    # Step II of the algorithm
+    K = KrawczykCertifiedEdgeLengthsEngine(
+        polished_hyperbolic_structure, bits_prec)
+    result = K.partially_verified_hyperbolic_structure()
+
+    # Step III-V of the algorithm
+    verify_engine = VerifyHyperbolicStructureEngine(result)
+
+    verify_engine.assert_verified_hyperbolic()
+
+    return result
+
+def compute_verified_hyperbolic_structure(
+            triangulation, source = 'orb', bits_prec = 53, verbose = False):
+
+    """
+    Computes a verified hyperbolic structure given a snappy.Triangulation.
+    If all verification tests pass, the result is an instance of
+    HyperbolicStructure with edge lengths being SageMath's
+    RealIntervalField. Otherwise, raises an exception subclassed from
+    VerificationError.
+
+    The argument source specifies whether Orb ('orb') or a python-only
+    implementation ('new') to find the initial unverified hyperbolic
+    structure is used. It can also be a path to a vgm file containing
+    the vertex gram matrices.
+
+    The precision can be specified by the argument bits_prec.
+
+        >>> from snappy import Triangulation
+        >>> T = Triangulation('kLLLLPQkbcghihjijhjtsmnnnegufa', remove_finite_vertices = False)
+        >>> bool(compute_verified_hyperbolic_structure(T, source = 'orb'))
+        True
+        >>> bool(compute_verified_hyperbolic_structure(T, source = 'new'))
+        True
+
+        >>> from sage.all import RealIntervalField, pi
+        >>> RIF = RealIntervalField(212)
+        >>> two_pi = RIF(2*pi)
+        >>> h = compute_verified_hyperbolic_structure(T, source = 'orb', bits_prec = 212)
+        >>> max([abs(d - two_pi) for d in h.angle_sums]) < RIF(1e-55)
+        True
+
+    """
+
+    approx = compute_unverified_hyperbolic_structure(triangulation, source, verbose)
+
+    return compute_verified_hyperbolic_structure_from_approx_structure(
+        approx, bits_prec, verbose)
+
+
+def _doctest():
+    import doctest
+    doctest.testmod()
+
+if __name__ == '__main__':
+    _doctest()