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

snappy/ptolemy/fieldExtensions.py

@@ -1,8 +1,8 @@
 from .polynomial import Polynomial, Monomial
 from . import matrix
 
-def my_rnfequation(base_poly, extension_poly):
 
+def my_rnfequation(base_poly, extension_poly):
     """
     This is returning the same as pari's
     rnfequation(base_poly, extension_poly, flag = 3) but
@@ -14,7 +14,7 @@ def my_rnfequation(base_poly, extension_poly):
 
     # Example: base_poly t^2 + 1, extension_poly s^3 + t
 
-    base_vars = base_poly.variables()  
+    base_vars = base_poly.variables()
     assert len(base_vars) == 1
     base_var = base_vars[0]                                 # would be y
     base_degree = base_poly.degree()                        # would be 2
@@ -30,18 +30,18 @@ def my_rnfequation(base_poly, extension_poly):
     # total degree
     total_degree = base_degree * extension_degree
 
-    # If the extension_poly does not contain base_var, e.g., 
+    # If the extension_poly does not contain base_var, e.g.,
     # s^2 + 1 and t^2 - 2, then we know that neither s nor t will
     # generate the entire field, so skip k = 0
     start_k = 0 if base_var in extension_vars else -1
-    
+
     # Try different k to find a generator for the total field
     for k in range(start_k, -100, -1):
-        
+
         # Use x = s + k * t as potential generator
 
         x = (  Polynomial.from_variable_name(extension_var)
-                   + Polynomial.constant_polynomial(k) * 
+                   + Polynomial.constant_polynomial(k) *
                      Polynomial.from_variable_name(base_var))
 
         # Holds the i-th power of x in the reduced form
@@ -63,8 +63,8 @@ def my_rnfequation(base_poly, extension_poly):
                              base_var, base_degree,
                              extension_var, extension_degree))
 
-            # Compute next power 
-            
+            # Compute next power
+
             power_of_x = (
                 _reduced_polynomial(
                     _reduced_polynomial(power_of_x * x,
@@ -98,11 +98,12 @@ def my_rnfequation(base_poly, extension_poly):
                 matrix.matrix_mult_vector(
                     mat_inv_t,
                     [0, 1] + (total_degree - 2) * [0]))
-            
+
             return new_poly, old_var_in_new_var, k
-    
+
     raise Exception("Should not get here")
 
+
 def _row_to_poly(row):
     zero = Polynomial.constant_polynomial(0)
     x = Polynomial.from_variable_name('x')
@@ -110,6 +111,7 @@ def _row_to_poly(row):
                  for i, c in enumerate(row)],
                zero)
 
+
 def _poly_to_row(poly, base_var, base_degree, extension_var, extension_degree):
     row = base_degree * extension_degree * [ 0 ]
     for m in poly.get_monomials():
@@ -120,8 +122,9 @@ def _poly_to_row(poly, base_var, base_degree, extension_var, extension_degree):
         row[index] = m.get_coefficient()
     return row
 
+
 def _reduced_polynomial(poly, mod_pol, mod_var, mod_degree):
-    
+
     def degree_of_monomial(m):
         vars = dict(m.get_vars())
         return vars.get(mod_var, 0)
@@ -148,4 +151,3 @@ def _reduced_polynomial(poly, mod_pol, mod_var, mod_degree):
         for m in poly.get_monomials():
             if degree_of_monomial(m) == degree:
                 poly = poly - reducing_polynomial(m) * mod_pol
-

snappy/ptolemy/findLoops.py

@@ -7,8 +7,8 @@ from . import matrix
 # We construct a fundamental domain of the Manifold from doubly truncated
 # simplices. See Figure 18 for simplices.
 #    Garoufalidis, Goerner, Zickert:
-#    Gluing Equations for PGL(n,C)-Representations of 3-Manifolds 
-#    http://arxiv.org/abs/1207.6711
+#    Gluing Equations for PGL(n,C)-Representations of 3-Manifolds
+#    https://arxiv.org/abs/1207.6711
 
 # We use SnapPy's _choose_generators_info to construct the same fundamental
 # domain and side pairing that SnapPy uses for the unsimplified fundamental
@@ -36,8 +36,8 @@ class Vertex(tuple):
     """
 
     def __new__(cls, tet, v0, v1, v2):
-        return super(Vertex, cls).__new__(cls, (tet, v0, v1, v2))
-    
+        return super().__new__(cls, (tet, v0, v1, v2))
+
     def edges_starting_at_vertex(self):
         """
         Return the three edges of the simplex starting at this point.
@@ -48,7 +48,8 @@ class Vertex(tuple):
     def __repr__(self):
         return "Vertex(%d,%d,%d,%d)" % self
 
-class Edge(object):
+
+class Edge():
     """
     Base class representing a directed edge of the doubly truncated
     simplex.
@@ -67,7 +68,7 @@ class Edge(object):
         """
         return self._start_point
 
-    def __pow__(self, other): 
+    def __pow__(self, other):
         """
         Invert an edge with ** -1
         """
@@ -77,6 +78,7 @@ class Edge(object):
     def __repr__(self):
         return type(self).__name__ + "(%r)" % (self._start_point,)
 
+
 class ShortEdge(Edge):
     """
     A short edge of a doubly truncated simplex.
@@ -89,6 +91,7 @@ class ShortEdge(Edge):
         tet, v0, v1, v2 = self._start_point
         return Vertex(tet, v0, v1, 6 - v0 - v1 - v2)
 
+
 class MiddleEdge(Edge):
     """
     A middle edge of a doubly truncated simplex.
@@ -102,6 +105,7 @@ class MiddleEdge(Edge):
 
         return Vertex(tet, v0, v2, v1)
 
+
 class LongEdge(Edge):
     """
     A log edge of a doubly truncated simplex.
@@ -114,6 +118,7 @@ class LongEdge(Edge):
         tet, v0, v1, v2 = self._start_point
         return Vertex(tet, v1, v0, v2)
 
+
 class Path(tuple):
     """
     A tuple of edges that form a path.
@@ -125,7 +130,7 @@ class Path(tuple):
         """
         assert other == -1
         return Path([edge ** -1 for edge in self][::-1])
-    
+
     def __mul__(self, other):
         """
         Two paths a, b can be composed as a * b.
@@ -136,6 +141,7 @@ class Path(tuple):
             return Path(self + other)
         return Path(self + (other,))
 
+
 def _penalty_of_path(path, penalties):
 
     def penalty(edge):
@@ -147,6 +153,7 @@ def _penalty_of_path(path, penalties):
 
     return sum([penalty(edge) for edge in path])
 
+
 def _perm4_iterator():
     for v0 in range(4):
         for v1 in range(4):
@@ -155,21 +162,22 @@ def _perm4_iterator():
                     if v2 != v0 and v2 != v1:
                         yield v0, v1, v2, 6 - v0 - v1 - v2
 
+
 def _compute_origin(choose_generators_info):
     """
     Using the info from SnapPy's choose_generators_info, return the vertex
     (0, 1, 2) of the simplex that SnapPy used to compute a spanning tree of
     the dual 1-skeleton.
     """
-
     # Picks the one tetrahedron with generator_path = -1.
     # If choose_generators_info comes from a regina triangulation, then
     # generator_path is missing and we pick the first tetrahedron.
 
-    tet = [ info['index'] for info in choose_generators_info
-            if info.get('generator_path', -1) == -1 ] [0]
+    tet = [info['index'] for info in choose_generators_info
+           if info.get('generator_path', -1) == -1][0]
     return Vertex(tet, 0, 1, 2)
 
+
 def _compute_point_identification_dict(choose_generators_info):
     """
     A vertex in the fundamental domain is an equivalence class of
@@ -181,17 +189,17 @@ def _compute_point_identification_dict(choose_generators_info):
     the set of equivalent triples.
     """
 
-    # Initialize: each vertex is mapped to set of only it self
-    d = dict( [ (Vertex(tet, v0, v1, v2), set([Vertex(tet, v0, v1, v2)]))
-                for tet in range(len(choose_generators_info))
-                for v0, v1, v2, v3 in _perm4_iterator() ] )
-    
+    # Initialize: each vertex is mapped to set of only itself
+    d = {Vertex(tet, v0, v1, v2): {Vertex(tet, v0, v1, v2)}
+         for tet in range(len(choose_generators_info))
+         for v0, v1, v2, v3 in _perm4_iterator()}
+
     # Go through all points on faces not corresponding to
     # generators
     for this_tet, info in enumerate(choose_generators_info):
         for this_v0, this_v1, this_v2, this_v3 in _perm4_iterator():
             if info['generators'][this_v0] == 0:
-                
+
                 # Determine the point
                 this_pt = Vertex(this_tet, this_v1, this_v2, this_v3)
 
@@ -212,6 +220,7 @@ def _compute_point_identification_dict(choose_generators_info):
 
     return d
 
+
 def _compute_point_to_shortest_path(point_identification_dict, origin,
                                     penalties):
     """
@@ -232,9 +241,9 @@ def _compute_point_to_shortest_path(point_identification_dict, origin,
     # this property. It maps all triples equivalent to pt to path.
 
     def identified_points_to_path(pt, path):
-        return dict(
-            [ (identified_pt, path)
-              for identified_pt in point_identification_dict[pt] ] )
+        return {
+            identified_pt: path
+              for identified_pt in point_identification_dict[pt] }
 
     # Trivial paths for points identified with origin
     previously_added = identified_points_to_path(origin, Path())
@@ -260,10 +269,10 @@ def _compute_point_to_shortest_path(point_identification_dict, origin,
                 # add that path
                 new_path = path * edge
                 new_end_point = edge.end_point()
-                
+
                 # If the end point of this edge does not have a path
                 # yet or the new path is shorter.
-                if (not new_end_point in d
+                if (new_end_point not in d
                     or _penalty_of_path(new_path, penalties) <
                                _penalty_of_path(d[new_end_point], penalties)):
                     new_paths.update(
@@ -275,6 +284,7 @@ def _compute_point_to_shortest_path(point_identification_dict, origin,
 
     return d
 
+
 def _compute_num_generators(choose_generators_info):
     """
     Compute the number of generators.
@@ -282,10 +292,10 @@ def _compute_num_generators(choose_generators_info):
 
     return max([ max(info['generators']) for info in choose_generators_info ])
 
+
 def _compute_loops_for_generators_from_info(choose_generators_info,
                                             point_to_shortest_path,
                                             penalties):
-    
     """
     Using the result of SnapPy's _choose_generators_info() that
     indicates which face pairings correspond to which generators and
@@ -330,7 +340,7 @@ def _compute_loops_for_generators_from_info(choose_generators_info,
                     or _penalty_of_path(new_loop, penalties) <
                                             _penalty_of_path(loop, penalties)):
                     loops_for_generators[generator_index - 1] = new_loop
-                    
+
     return loops_for_generators
 
 
@@ -348,7 +358,7 @@ def compute_loops_for_generators(M, penalties):
     # Get the necessary information from SnapPea kernel
     M._choose_generators(False, False)
     choose_generators_info = M._choose_generators_info()
-    
+
     # Compute which vertices of doubly truncated simplices are identified
     # to form the fundamental domain
     point_identification_dict = _compute_point_identification_dict(
@@ -356,7 +366,7 @@ def compute_loops_for_generators(M, penalties):
 
     # Pick an origin
     origin = _compute_origin(choose_generators_info)
-    
+
     # Compute shortest paths form the origin to every vertex
     point_to_shortest_path = _compute_point_to_shortest_path(
         point_identification_dict, origin, penalties)
@@ -364,7 +374,8 @@ def compute_loops_for_generators(M, penalties):
     # Compute the loops
     return _compute_loops_for_generators_from_info(
         choose_generators_info, point_to_shortest_path, penalties)
-    
+
+
 def _evaluate_path(coordinate_object, path):
     """
     Given PtolemyCoordinates or CrossRatios (or more generally, any object that
@@ -389,7 +400,7 @@ def _evaluate_path(coordinate_object, path):
             raise Exception("Edge of unknown type in path")
 
         m = matrix.matrix_mult(m, matrix_method(*edge.start_point()))
-        
+
     return m
 
 
@@ -407,12 +418,13 @@ def images_of_original_generators(coordinate_object, penalties):
     if M is None:
         raise Exception("Need to have a manifold")
 
-    loops = compute_loops_for_generators(M, penalties = penalties)
+    loops = compute_loops_for_generators(M, penalties=penalties)
 
     return (
         [ _evaluate_path(coordinate_object, loop      ) for loop in loops ],
         [ _evaluate_path(coordinate_object, loop ** -1) for loop in loops ])
 
+
 def _apply_hom_to_word(word, G):
     # No G given means nothing is done to the word
     if G is None:
@@ -426,7 +438,7 @@ def _apply_hom_to_word(word, G):
         # Get how each letter translates into the original generators
         imgs = G.generators_in_originals()
         for letter in word:
-            
+
             if letter.isupper():
                 # Upper case letter correspond to inverses
                 # Inverse is formed by swapping case, then reversing string
@@ -437,9 +449,10 @@ def _apply_hom_to_word(word, G):
 
     raise Exception("Given argument is not a SnapPy fundamental group")
 
+
 def evaluate_word(identity_matrix, generator_matrices, inverse_matrices,
                   word, G):
-    
+
     # Start with the identity matrix
     m = identity_matrix
 
@@ -458,4 +471,3 @@ def evaluate_word(identity_matrix, generator_matrices, inverse_matrices,
         m = matrix.matrix_mult(m, g)
 
     return m
-

snappy/ptolemy/geometricRep.py

@@ -1,9 +1,8 @@
-def compute_geometric_solution(M, N = 2, numerical = False,
-                               engine = None,
-                               memory_limit = 750000000, directory = None,
-                               prefer_rur = False, data_url = False,
-                               verbose = None):
-
+def compute_geometric_solution(M, N=2, numerical=False,
+                               engine=None,
+                               memory_limit=750000000, directory=None,
+                               prefer_rur=False, data_url=False,
+                               verbose=None):
     """
     Given a manifold M, compute the exact or numerical solutions to the
     Ptolemy variety (pass numerical = True for numerical solutions). The additional
@@ -18,19 +17,19 @@ def compute_geometric_solution(M, N = 2, numerical = False,
         verbose = (engine == 'retrieve')
 
     obstruction_class = 'all' if N % 2 == 0 else None
-    varieties = M.ptolemy_variety(N, obstruction_class = obstruction_class)
+    varieties = M.ptolemy_variety(N, obstruction_class=obstruction_class)
 
     if engine == 'retrieve':
-        sols = varieties.retrieve_solutions(numerical = numerical,
-                                           prefer_rur = prefer_rur,
-                                           data_url = data_url,
-                                           verbose = verbose)
+        sols = varieties.retrieve_solutions(numerical=numerical,
+                                           prefer_rur=prefer_rur,
+                                           data_url=data_url,
+                                           verbose=verbose)
     else:
-        sols = varieties.compute_solutions(engine = engine,
-                                          numerical = numerical,
-                                          memory_limit = memory_limit,
-                                          directory = directory,
-                                          verbose = verbose)
+        sols = varieties.compute_solutions(engine=engine,
+                                          numerical=numerical,
+                                          memory_limit=memory_limit,
+                                          directory=directory,
+                                          verbose=verbose)
 
     for sol in sols.flatten(3):
         if sol.is_geometric():
@@ -38,12 +37,12 @@ def compute_geometric_solution(M, N = 2, numerical = False,
 
     return None
 
-def retrieve_geometric_solution(M, N = 2,
-                                numerical = False,
-                                prefer_rur = False,
-                                data_url = None,
-                                verbose = True):
 
+def retrieve_geometric_solution(M, N=2,
+                                numerical=False,
+                                prefer_rur=False,
+                                data_url=None,
+                                verbose=True):
     """
     Given a manifold M, retrieve the exact or numerical solutions to the
     Ptolemy variety (pass numerical = True for numerical solutions). The additional
@@ -54,8 +53,7 @@ def retrieve_geometric_solution(M, N = 2,
 
     """
 
-    
-    return compute_geometric_solution(M, N, numerical = numerical,
-                                      engine = 'retrieve',
-                                      prefer_rur = prefer_rur,
-                                      data_url = data_url, verbose = verbose)
+    return compute_geometric_solution(M, N, numerical=numerical,
+                                      engine='retrieve',
+                                      prefer_rur=prefer_rur,
+                                      data_url=data_url, verbose=verbose)

snappy/ptolemy/homology.py

@@ -1,10 +1,12 @@
 from . import matrix
 
+
 def _gcd(s, t):
     if t == 0:
         return s
     return _gcd(t, s % t)
 
+
 def homology_basis_representatives_with_orders(d1, d2, N):
     """
     Given two matrices d1 and d2 such that d1 * d2 = 0, computes the
@@ -16,7 +18,7 @@ def homology_basis_representatives_with_orders(d1, d2, N):
     if it is finite otherwise 0.
     """
 
-    # two consecutive maps in a chain complex should give zero    
+    # two consecutive maps in a chain complex should give zero
     assert matrix.is_matrix_zero(
         matrix.matrix_mult(d1, d2))
 
@@ -31,7 +33,7 @@ def homology_basis_representatives_with_orders(d1, d2, N):
 
     # Perform consistency checks
     matrix.test_simultaneous_smith_normal_form(
-        d1, d2, 
+        d1, d2,
         basechange0, basechange1, basechange2,
         transformed_d1, transformed_d2)
 
@@ -67,7 +69,7 @@ def homology_basis_representatives_with_orders(d1, d2, N):
             # If gcd(e, N) % N is 0, the kernel is Z/N. If 1, the kernel is 0.
             # Otherwise, N / (gcd(e, N) % N) is generating the kernel and the
             # kernel has size gcd(e, N) % N).
-            
+
             # Example: Z/6 -> Z/6, x |-> 5 * x has full image Z/6 because
             # gcd(5, 6) = 1. The kernel is 0.
 
@@ -117,9 +119,10 @@ def homology_basis_representatives_with_orders(d1, d2, N):
 
         # d1 entry is 1, so the basis vector or any multiple of it
         # is in the kernel. Do not add it
-            
+
     return homology_basis
 
+
 def homology_representatives(d1, d2, N):
     """
     Given two matrices d1 and d2 such that d1 * d2 = 0, computes the
@@ -136,11 +139,13 @@ def homology_representatives(d1, d2, N):
     # Enumerate all linear combinations of the basis elements
     return _enumerate_from_basis(homology_basis, matrix.num_cols(d1), N)
 
+
 def _enumerate_from_basis(basis, l, N):
     """
-    Given a list of pairs (v_i, o_i) where each v1 is a vector of length l and 
-    an integer N > 2, iterate through all linear combinations 
-        k_0 v_0 + k_1 v_1 + ... + k_m v_m (modulo N) where k_i = 0, ..., o_i.
+    Given a list of pairs `(v_i, o_i)` where each `v_i` is a vector of length l
+    and an integer N > 2, iterate through all linear combinations
+    `k_0 v_0 + k_1 v_1 + ... + k_m v_m` (modulo N) where `k_i = 0, ..., o_i`.
+
     If basis is empty, just return zero vector of length l.
     """