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

snappy/dev/extended_ptolemy/complexVolumesClosed.py

@@ -91,26 +91,59 @@ def has_value(v, values):
     RIF = RealIntervalField(212)
 
     for value in values:
-        if abs(RIF(v.imag()) - RIF(value.imag())) < 1e-20:
+        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) < 1e-20:
+                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))
 
-    cvol = M.complex_volume() * sage.all.I
-
-    # Because of ordering issues, only correct up to pi^2/2
-    cvols = sum(complex_volumes(M, precision = 300), [])
-
-    print(has_value(cvol, cvols))
+    # 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/extended.py

@@ -1,4 +1,3 @@
-from __future__ import print_function
 """
 Computing the extended Ptolemy variety of Goerner-Zickert for N = 2.
 """
@@ -17,10 +16,12 @@ t3m_edge_to_tuple = {t3m.E01:(0,1), t3m.E02:(0,2), t3m.E03:(0,3),
 to_t3m_edge = {(0,1):t3m.E01, (0,2):t3m.E02, (0,3):t3m.E03,
                          (1,2):t3m.E12, (1,3):t3m.E13, (2,3):t3m.E23}
 
+
 def arrow(mcomplex, tet, face, edge):
     return t3m.Arrow(to_t3m_edge[edge], t3m.TwoSubsimplices[face],
                      mcomplex.Tetrahedra[tet])
 
+
 def faces_around_edge(mcomplex, tet, edge):
     face = min(set(range(4)) - set(edge))
     ans = [(tet, face, edge)]
@@ -56,17 +57,20 @@ def arrows_around_edges(manifold):
     ans = []
     return [faces_around_edge(T, tet, edge) for tet, edge in starts]
 
+
 def parse_ptolemy_edge(var):
     c, index, tet = var.split('_')
     tet = int(tet)
     edge = tuple(i for i in range(4) if index[i] == '1')
     return tet, edge
 
+
 def parse_ptolemy_face(var):
     s, index, tet = var.split('_')
     return int(tet), int(index)
 
-class EdgeGluings(object):
+
+class EdgeGluings():
     def __init__(self, gen_obs_class):
         assert gen_obs_class._N == 2
         M = gen_obs_class._manifold
@@ -149,7 +153,7 @@ def simplify_equation(poly):
 def extended_ptolemy_equations(manifold, gen_obs_class=None,
                                nonzero_cond=True, return_full_var_dict = False,
                                notation = 'short'):
-    """
+    r"""
     We assign ptolemy coordinates ['a', 'b', 'c', 'd', 'e', 'f'] to the
     *directed* edges::
 
@@ -157,27 +161,25 @@ def extended_ptolemy_equations(manifold, gen_obs_class=None,
 
 
     where recall that the basic orientation convention of t3m and
-    SnapPy is that a positively oriented simplex is as below.
-
-
-              1
-             /|\
-           d/ | \e
-           /  |  \
-          /   |   \
-         2----|----3   with back edge from 2 to 3 labelled f.
-          \   |   /
-          b\  |a /c
-            \ | /
-             \|/
-              0
+    SnapPy is that a positively oriented simplex is as below. ::
+
+             1
+            /|\
+         d / | \ e
+          /  |  \
+         /   |   \
+        2----|----3   with back edge from 2 to 3 labelled f.
+         \   |   /
+        b \  |a / c
+           \ | /
+            \|/
+             0
 
     sage: M = Manifold('m016')
     sage: I = extended_ptolemy_equations(M)
     sage: I.dimension()
     1
     """
-
     if gen_obs_class is None:
         gen_obs_class = manifold.ptolemy_generalized_obstruction_classes(2)[0]
 
@@ -197,7 +199,8 @@ def extended_ptolemy_equations(manifold, gen_obs_class=None,
                      'c_0011_']
         first_var_name = 'c_1100_0'
 
-    tet_vars = [ x + repr(d) for d in range(n) for x in var_names ]
+    tet_vars = [x + repr(d) for d in range(n) for x in var_names]
+
     def var(tet, edge):
         return tet_vars[6*tet + directed_edges.index(edge)]
 
@@ -258,6 +261,7 @@ def extended_ptolemy_equations(manifold, gen_obs_class=None,
     else:
         return R.ideal(rels)
 
+
 def apoly(manifold, rational_coeff=False, method='sage'):
     """
     Computes the SL(2, C) version of the A-polynomial starting from
@@ -273,7 +277,7 @@ def apoly(manifold, rational_coeff=False, method='sage'):
     """
     I = extended_ptolemy_equations(manifold)
     R = I.ring()
-    if rational_coeff == False:
+    if rational_coeff is False:
         F = GF(31991)
         R = R.change_ring(F)
         I = I.change_ring(R)
@@ -287,6 +291,7 @@ def apoly(manifold, rational_coeff=False, method='sage'):
     else:
         raise ValueError("method flag should be in ['sage', 'M2']")
 
+
 def sample_apoly_points_via_giac_rur(manifold, n):
     import giac_rur
     I = extended_ptolemy_equations(manifold)
@@ -388,12 +393,14 @@ def shapes_of_SL2C_reps_for_filled(manifold, phc_solver=None):
         ans.append(shape_dict)
     return ans
 
+
 def doctest_globals():
     import snappy
-    return {'Manifold':snappy.Manifold}
+    return {'Manifold': snappy.Manifold}
+
 
 if __name__ == '__main__':
-   from snappy.sage_helper import doctest_modules
-   import sys
-   current_module = sys.modules[__name__]
-   doctest_modules([current_module], extraglobs=doctest_globals())
+    from snappy.sage_helper import doctest_modules
+    import sys
+    current_module = sys.modules[__name__]
+    doctest_modules([current_module], extraglobs=doctest_globals())

snappy/dev/extended_ptolemy/giac_rur.py

@@ -60,9 +60,22 @@ def rational_univariate_representation(ideal):
 
     """
     R = ideal.ring()
-    vars = list(R.gens())
+
+    # A "feature" introduced in Sage-9.4 is that
+    # ideal.gens() vs R.gens()
+    # returns
+    # a <class 'sage.rings.polynomial.multi_polynomial_sequence.PolynomialSequence_generic’>
+    # vs a
+    # <class 'sage.rings.polynomial.multi_polynomial_libsingular.MPolynomial_libsingular’>
+    # so that giac(_) turns the variable x into x vs sageVARx.
+    #
+    # And giving "gbasis([x],[sageVARx],rur)" instead of "gbasis([x],[x],rur)" doesn't
+    # produce the desired result...
+    #
+    # Thus, we have the following work-around:
+    good_vars = R.ideal(R.gens()).gens()
     J = giac(ideal.gens())
-    rur = J.gbasis(vars, 'rur')
+    rur = J.gbasis(good_vars, 'rur')
     # Yikes: giacpy_sage vs the giac interface give different types.
     # So using repr.
     if repr(rur[0]) != 'rur':
@@ -97,18 +110,20 @@ def rational_univariate_representation(ideal):
 
         denom = toK(rur[3])
         rep = [toK(f)/denom for f in rur[4:]]
-        sub_dict = dict(zip(vars, rep))
+        sub_dict = dict(zip(R.gens(), rep))
         assert all(g.subs(sub_dict) == 0 for g in ideal.gens())
         ans.append((K, sub_dict, e))
 
     return ans
 
+
 def doctest_globals():
     import snappy
-    return {'Manifold':snappy.Manifold}
+    return {'Manifold': snappy.Manifold}
+
 
 if __name__ == '__main__':
-   from snappy.sage_helper import doctest_modules
-   import sys
-   current_module = sys.modules[__name__]
-   doctest_modules([current_module], extraglobs=doctest_globals())
+    from snappy.sage_helper import doctest_modules
+    import sys
+    current_module = sys.modules[__name__]
+    doctest_modules([current_module], extraglobs=doctest_globals())

snappy/dev/extended_ptolemy/phc_wrapper.py

@@ -41,9 +41,9 @@ def restore_forbidden(var_str):
 def ideal_to_file(ideal, filename):
     outfile = open(filename, 'w')
     polys = ideal.gens()
-    outfile.write('%d\n' % len(polys))
+    outfile.write(r'%d\n' % len(polys))
     for p in polys:
-        outfile.write('   ' + remove_forbidden(repr(p)) + ';\n')
+        outfile.write('   ' + remove_forbidden(repr(p)) + r';\n')
     outfile.close()
 
 def parse_file(filename, prec=53):
@@ -55,14 +55,14 @@ def parse_file(filename, prec=53):
     data = data.split('THE SOLUTIONS')[-1]
     data = re.subn('[*]{3,}', '', data)[0]
     ans = []
-    solutions = re.findall('(solution \d+ : \s* start residual .*?) ==', data, re.DOTALL)
+    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('^m : (\d+)', sol, re.MULTILINE).group(1))
-        err = float(re.search('== err :\s+(.*?)\s+= ', sol).group(1))
-        coors = re.findall('^ (.*) :\s+(\S*)\s+(\S*)', sol, re.MULTILINE)
+        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})
@@ -70,8 +70,8 @@ def parse_file(filename, prec=53):
             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('Number of real solutions\s+:\s(.*).', data).group(1))
-    num_complex = int(re.search('Number of complex solutions\s+:\s(.*).', data).group(1))
+    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
@@ -185,9 +185,9 @@ def direct_hack(backend, ideal, **kwargs):
     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('\n', '')
+    problem_data = json.dumps(data).encode('base64').replace(r'\n', '')
     ans_data = os.popen('sage -python ' + __file__ + ' ' + problem_data).read()
-    ans_data = re.sub('PHCv.*? released .*? works!\n', '',  ans_data)
+    ans_data = re.sub(r'PHCv.*? released .*? works!\n', '',  ans_data)
     if len(ans_data):
         ans = json.loads(ans_data)
         for sol in ans:

snappy/dev/vericlosed/computeApproxHyperbolicStructureOrb.py

@@ -12,7 +12,8 @@ import os
     
 __all__ = ['compute_approx_hyperbolic_structure_orb']
 
-class TmpDir(object):
+
+class TmpDir():
     """
     To be used in a with statement, creating a temporary
     directory deleted at the end of the with statement.

snappy/dev/vericlosed/gimbalLoopFinder.py

@@ -46,7 +46,7 @@ class GimbalLoopFinder:
         edge_index_and_end = (
             self.truncated_complex.get_edge_index_and_end_from_tet_and_perm(
                 edge.tet_and_perm))
-        if not edge_index_and_end in self.uncovered_edge_ends:
+        if edge_index_and_end not in self.uncovered_edge_ends:
             return position
 
         self.uncovered_edge_ends.remove(edge_index_and_end)
@@ -114,10 +114,11 @@ class GimbalLoopFinder:
     def __repr__(self):
         return repr(self.edges)
 
+
 def _group_loop(loop):
-    indices = [ i for i, edge in enumerate(loop)
-                if edge.subcomplex_type == 'edgeLoop' ] + [ len(loop) ]
-    if not 0 in indices:
+    indices = [i for i, edge in enumerate(loop)
+               if edge.subcomplex_type == 'edgeLoop'] + [len(loop)]
+    if 0 not in indices:
         raise Exception("Missing edgeLoop")
     result = [
         [loop[indices[i]], loop[indices[i]+1:indices[i+1]]]
@@ -127,4 +128,3 @@ def _group_loop(loop):
         raise Exception("Error in _group_loop")
 
     return result
-    

snappy/dev/vericlosed/hyperbolicStructure.py

@@ -281,9 +281,9 @@ def _find_rows_and_columns_for_full_rank_submatrix(m, expected_rank):
         for c in cols_left:
             m.add_multiple_of_column(c, col, -m[row, c  ] / m[row, col])
 
-    return (
-        [ row for row in range(num_rows) if not row in rows_left ],
-        [ col for col in range(num_cols) if not col in cols_left ])
+    return ([row for row in range(num_rows) if row not in rows_left],
+            [col for col in range(num_cols) if col not in cols_left])
+
 
 def _cofactor_matrices_for_submatrices(m):
     def cofactor_matrix(r, c):

snappy/dev/vericlosed/oneVertexTruncatedComplex.py

@@ -5,7 +5,7 @@ from truncatedComplex import *
 class OneVertexTruncatedComplex(TruncatedComplex):
 
     def __init__(self, hyperbolic_structure):
-        super(OneVertexTruncatedComplex, self).__init__(
+        super().__init__(
             hyperbolic_structure.mcomplex)
 
         self.hyperbolic_structure = hyperbolic_structure
@@ -50,7 +50,7 @@ class OneVertexTruncatedComplex(TruncatedComplex):
                     
                     key = self.get_key(tet_and_perm_of_end)
                 
-                    if not key in self.tet_and_perm_to_edge:
+                    if key not in self.tet_and_perm_to_edge:
                         self.tet_and_perm_to_edge[key] = edge
                         pending.append(tet_and_perm_of_end)
                         

snappy/dev/vericlosed/truncatedComplex.py

@@ -2,9 +2,10 @@ from snappy.snap import t3mlite as t3m
 
 __all__ = ['TruncatedComplex']
 
-class TruncatedComplex(object):
 
-    class SubcomplexBase(object):
+class TruncatedComplex():
+
+    class SubcomplexBase():
         def __init__(self, subcomplex_type, tet_and_perm):
             self.subcomplex_type = subcomplex_type
             self.tet_and_perm = tet_and_perm

snappy/dev/vericlosed/verifyHyperbolicStructureEngine.py

@@ -7,6 +7,7 @@ from sage.all import matrix, prod, RealDoubleField, pi
 
 __all__ = [ 'VerifyHyperbolicStructureEngine']
 
+
 class VerifyHyperbolicStructureEngine:
     def __init__(self, hyperbolic_structure):
         self.hyperbolic_structure = hyperbolic_structure
@@ -21,8 +22,8 @@ class VerifyHyperbolicStructureEngine:
         num_edges = len(self.mcomplex.Edges)
         exact_edges = set(hyperbolic_structure.exact_edges)
 
-        self.approx_edges = [
-            i for i in range(num_edges) if not i in exact_edges ]
+        self.approx_edges = [i for i in range(num_edges)
+                             if i not in exact_edges]
 
         self.truncated_complex = TruncatedComplex(self.mcomplex)
 
@@ -74,7 +75,7 @@ class VerifyHyperbolicStructureEngine:
         two_pi = RIF(2 * pi)
 
         for angle in self.hyperbolic_structure.angle_sums:
-            if not two_pi in angle:
+            if two_pi not in angle:
                 raise AngleSumIntervalNotContainingTwoPiError()
 
     def assert_vertex_gram_matrices_valid(self):

snappy/doc/_sources/additional_classes.rst.txt

@@ -11,6 +11,7 @@ AbelianGroup
 ..   autoclass:: AbelianGroup
      :members:
      :inherited-members:
+     :exclude-members: coefficients
 
 FundamentalGroup
 ================

snappy/doc/_sources/credits.rst.txt

@@ -20,7 +20,10 @@ Additional contributions:
 
 * Robert Lipschitz and Jennet Dickinson, improvements to Spherogram.
 
-* Malik Obeidin, improvements to Spherogram and the manifold databases.
+* Malik Obeidin, improvements to Spherogram and the manifold
+  databases.
+
+* Malik Obeidin and Cameron Rudd, exterior to link diagram code.
 
 * Jose Sanchez, 3D printing code.
 
@@ -36,6 +39,8 @@ Additional contributions:
 *  `QD quad-double library
    <http://crd-legacy.lbl.gov/~dhbailey/mpdist/>`_.
 
+* Frédéric Chapoton, code cleanup and linting.
+
 * Others, please let Marc or Nathan know if we've forgotten you. 
 
 Citing SnapPy