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

snappy/ptolemy/reginaWrapper.py

@@ -13,6 +13,7 @@ from . import utilities
 
 # See addl_code/ptolemy_equations.c for more comments.
 
+
 class NTriangulationForPtolemy(NTriangulation):
 
     """
@@ -39,7 +40,7 @@ class NTriangulationForPtolemy(NTriangulation):
         """
         Constructor - takes same arguments as NTriangulation.
         """
-        super(NTriangulationForPtolemy, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
 
         # Make sure we are oriented
         if not self.isOriented():
@@ -61,7 +62,7 @@ class NTriangulationForPtolemy(NTriangulation):
         """
 
         # Create temporary file and write text to it
-        f = tempfile.NamedTemporaryFile(delete = False)
+        f = tempfile.NamedTemporaryFile(delete=False)
         filename = f.name
         f.write(text)
         f.close()
@@ -80,7 +81,6 @@ class NTriangulationForPtolemy(NTriangulation):
 
         return NTriangulationForPtolemy(T)
 
-
     def ptolemy_obstruction_classes(self):
         """
         Returns the obstruction classes needed to compute the
@@ -105,12 +105,14 @@ class NTriangulationForPtolemy(NTriangulation):
         return manifoldMethods.get_ptolemy_obstruction_classes(self)
 
     def ptolemy_generalized_obstruction_classes(self, N):
-
         """
-                Returns the obstruction classes needed to compute
-        PGL(N,C)-representations for any N, i.e., it returns a list with
+        Return the obstruction classes needed to compute
+        PGL(N,C)-representations for any N.
+
+        It returns a list with
         a representative cocycle for each element in
-        H^2(M, boundary M; Z/N) / (Z/N)^* where (Z/N)^* are the units in Z/N.
+        ``H^2(M, boundary M; Z/N) / (Z/N)^*``
+        where ``(Z/N)^*`` are the units in Z/N.
         The first element in the list always corresponds to the trivial
         obstruction class.
         The generalized ptolemy obstruction classes are thus a generalization
@@ -131,14 +133,12 @@ class NTriangulationForPtolemy(NTriangulation):
 
         See  help(Manifold.ptolemy_generalized_obstruction_classes()) for more.
         """
-
         return (
             manifoldMethods.get_generalized_ptolemy_obstruction_classes(
                 self, N))
 
-    def ptolemy_variety(self, N, obstruction_class = None,
-                        simplify = True, eliminate_fixed_ptolemys = False):
-
+    def ptolemy_variety(self, N, obstruction_class=None,
+                        simplify=True, eliminate_fixed_ptolemys=False):
         """
         M.ptolemy_variety(N, obstruction_class = None, simplify = True, eliminate_fixed_ptolemys = False)
 
@@ -146,10 +146,10 @@ class NTriangulationForPtolemy(NTriangulation):
 
         * Stavros Garoufalidis, Dyland Thurston, Christian K. Zickert:
           "The Complex Volume of SL(n,C)-Representations of 3-Manifolds"
-          (http://arxiv.org/abs/1111.2828)
+          (https://arxiv.org/abs/1111.2828)
         * Stavros Garoufalidis, Matthias Goerner, Christian K. Zickert:
           "Gluing Equations for PGL(n,C)-Representations of 3-Manifolds "
-          (http://arxiv.org/abs/1207.6711)
+          (https://arxiv.org/abs/1207.6711)
 
         The variety can be exported to magma or sage and solved there. The
         solutions can be processed to compute invariants.
@@ -169,8 +169,8 @@ class NTriangulationForPtolemy(NTriangulation):
 
         return manifoldMethods.get_ptolemy_variety(
             self, N, obstruction_class,
-            simplify = simplify,
-            eliminate_fixed_ptolemys = eliminate_fixed_ptolemys)
+            simplify=simplify,
+            eliminate_fixed_ptolemys=eliminate_fixed_ptolemys)
 
     def name(self):
         """
@@ -373,7 +373,6 @@ class NTriangulationForPtolemy(NTriangulation):
         Also see _ptolemy_equations_boundary_map_2.
         """
 
-
         def process_triangle(triangle):
             row = [ 0 for i in range(self.getNumberOfTetrahedra()) ]
             for i in range(2):
@@ -409,7 +408,7 @@ class NTriangulationForPtolemy(NTriangulation):
 
         for tet_index, tet in enumerate(self.getTetrahedra()):
             for pt in utilities.quadruples_with_fixed_sum_iterator(
-                                                       N, skipVertices = True):
+                                                       N, skipVertices=True):
 
                 row = (N - 1) * self.getNumberOfVertices() * [ 0 ]
 
@@ -440,7 +439,7 @@ class NTriangulationForPtolemy(NTriangulation):
         # Following Remark 5.7 of
         # Garoufalidis, Goerner, Zickert:
         # Gluing Equations for PGL(n,C)-Representations of 3-Manifolds
-        # http://arxiv.org/abs/1207.6711
+        # https://arxiv.org/abs/1207.6711
         # we discard all even entries and get a permutation called
         # "effective_perm" here.
         effective_perm = []
@@ -465,8 +464,8 @@ class NTriangulationForPtolemy(NTriangulation):
         if len(effective_perm) == 3:
             # Test whether cyclic permutation by i, including identity
             for i in range(3):
-                if ( (effective_perm[ i     ] < effective_perm[(i+1)%3]) and
-                     (effective_perm[(i+1)%3] < effective_perm[(i+2)%3])):
+                if (effective_perm[i] < effective_perm[(i + 1) % 3]
+                        < effective_perm[(i + 2) % 3]):
                     return +1
             return -1
 
@@ -517,8 +516,6 @@ class NTriangulationForPtolemy(NTriangulation):
             self._get_obstruction_on_edge(obstruction_class,
                                           other_tet, other_v0, other_v1))
 
-
-
     def _get_obstruction_on_edges(self, obstruction_class, tet, face, N):
         """
         This reimplements _get_obstruction_on_edges from
@@ -561,13 +558,12 @@ class NTriangulationForPtolemy(NTriangulation):
         obstruction class by _get_obstruction_on_edges.
         """
 
-
         v1 = (face + 2) % 4
         v2 = (face + 3) % 4
         return ptolemy_index[v1] * e01 + ptolemy_index[v2] * e02
 
     def _ptolemy_equations_identified_coordinates(self, N,
-                                                  obstruction_class = None):
+                                                  obstruction_class=None):
 
         identifications = []
 
@@ -593,7 +589,7 @@ class NTriangulationForPtolemy(NTriangulation):
 
             # Iterate through all the integral points on the face
             for triple in utilities.triples_with_fixed_sum_iterator(
-                                                       N, skipVertices = True):
+                                                       N, skipVertices=True):
                 # The face integral points are obtained by inserting a 0
                 ptolemy_index = triple[0:face] + (0,) + triple[face:]
                 # Get the corresponding integral point on the other tetrahedron
@@ -615,7 +611,7 @@ class NTriangulationForPtolemy(NTriangulation):
                     power = 0
 
                 # Get the two corresponding Ptolemy coordinates
-                ptolemy       = ('c_%d%d%d%d' % ptolemy_index +
+                ptolemy = ('c_%d%d%d%d' % ptolemy_index +
                                  '_%d' % tet_index)
                 other_ptolemy = ('c_%d%d%d%d' % other_ptolemy_index +
                                  '_%d' % other_tet_index)
@@ -648,8 +644,8 @@ class NTriangulationForPtolemy(NTriangulation):
         non_generator_triangles = self.maximalForestInDualSkeleton()
 
         # All other triangles are
-        generator_triangles = [ triangle for triangle in self.getTriangles()
-                                if not triangle in non_generator_triangles ]
+        generator_triangles = [triangle for triangle in self.getTriangles()
+                               if triangle not in non_generator_triangles]
 
         def get_neighbors(tet):
             """
@@ -673,7 +669,7 @@ class NTriangulationForPtolemy(NTriangulation):
             """
             # Get corresponding triangle
             triangle = tet.getTriangle(face)
-            if not triangle in generator_triangles:
+            if triangle not in generator_triangles:
                 # Not a generator, return 0
                 return 0
             # Get the index of the generator, first generator is indexed 1

snappy/ptolemy/rur.py

@@ -1,6 +1,3 @@
-import operator
-import functools
-
 # Dependency on pari for:
 # * from_pari_fraction_and_number_field
 # * evaluate_at_root
@@ -10,11 +7,12 @@ import functools
 
 from ..sage_helper import _within_sage
 from ..pari import Gen, pari
+from ..math_basics import prod
 if _within_sage:
     from sage.rings.integer import Integer
 
 
-class RUR(object):
+class RUR():
 
     """
     A Rational Univariate Representation of an algebraic number.
@@ -247,7 +245,6 @@ class RUR(object):
         return '%s / ( %s )' % (numerator, denominator)
 
     def number_field(self):
-
         """
         Returns the polynomial c such that evaluating the fraction
         at one of the roots yields the algebraic number this RUR is
@@ -260,7 +257,6 @@ class RUR(object):
         return None
 
     def evaluate_at_root(self, root):
-
         """
         Given a numerical value for a root of the polynomial returned
         by number_field, evaluates all polynomials at that root and
@@ -292,7 +288,7 @@ class RUR(object):
 
             return pari(p)
 
-        return _prod(
+        return prod(
             [ evaluate_poly(p) ** e for p, e in self._polymod_exponent_pairs ])
 
     def multiply_terms(self):
@@ -414,7 +410,7 @@ class RUR(object):
         return self._filtered_terms( -1)
 
     def _multiply_terms(self, sgn):
-        return _prod([ p ** abs(e) for p, e in self._filtered_terms(sgn) ])
+        return prod([ p ** abs(e) for p, e in self._filtered_terms(sgn) ])
 
     def _numerator(self):
         return self._multiply_terms( +1)
@@ -447,7 +443,7 @@ class RUR(object):
                     return
 
         def term_to_expand_fraction_by(old_terms):
-            result = [ pair for pair in new_denominator_terms ]
+            result = list(new_denominator_terms)
             for p, e in old_terms:
                 if e < 0:
                     subtract_denominator_from_list(p, e, result)
@@ -455,7 +451,7 @@ class RUR(object):
             for p, e in result:
                 assert e <= 0
 
-            return _prod([ p ** -e for p, e in result if e < 0 ])
+            return prod([ p ** -e for p, e in result if e < 0 ])
 
         self_expand = term_to_expand_fraction_by( self._denominator_terms())
         other_expand = term_to_expand_fraction_by(other._denominator_terms())
@@ -547,7 +543,3 @@ class RUR(object):
             return self._is_zero()
 
         return (self / other)._is_one()
-
-
-def _prod(iterable):
-    return functools.reduce(operator.mul, iterable, 1)

snappy/ptolemy/solutionsToPrimeIdealGroebnerBasis.py

@@ -18,12 +18,12 @@ from ..pari import pari
 
 # This is broken down in three steps.
 
-# Step 1: Split into extensions and assingments
+# Step 1: Split into extensions and assignments
 #    extensions, assignments = extensions_and_assignments(polys)
 
 # Split the list of polynomials into two lists, the first list
 # contains triples (poly, var, degree) forming a tower of
-# field extensons and the second group is a dictionary assigning
+# field extensions and the second group is a dictionary assigning
 # all remaining variables polynomials in the variables in the tower.
 
 # Example:
@@ -45,7 +45,7 @@ from ..pari import pari
 # So assignments will be { 'a': t^3 - 1, 'b': 2}.
 #
 # extensions will be empty if the solutions are in Q.
-    
+
 # Step 2: Process the extensions
 #    number_field, ext_assignments = process_extensions_to_pari(extensions)
 #
@@ -57,11 +57,12 @@ from ..pari import pari
 
 # Step 3: Subsituiting
 #    assignments = update_assignments_and_merge(assignments, ext_assignments)
-    
+
 # The other variables are given as polynomials in the variables from
 # the field extension tower, do the substituition to convert them
 # into polynomials in x
 
+
 def _only_var_left_in_poly(poly, extension_vars):
     '''
     Checks whether that there is only one other variable besides
@@ -78,6 +79,7 @@ def _only_var_left_in_poly(poly, extension_vars):
         return None
     return list(vars_left)[0]
 
+
 def _next_var_and_poly(polys, extension_vars):
     '''
     Applies _only_var_left_in_poly to find a polynomial that has
@@ -94,21 +96,22 @@ def _next_var_and_poly(polys, extension_vars):
                     "solve is probably not in lexicographic order or of a "
                     "0-dimensional ideal!")
 
+
 def _remove(l, element):
     '''
     Returns a copy of list without element.
     '''
-    return [x for x in l if not x is element]
+    return [x for x in l if x is not element]
+
 
 def extensions_and_assignments(polys):
     '''
     Splits into extensions and assignments s in example given above
     in _exact_solutions.
     '''
-
-    extensions = [ ] # extension polynomials
-    extension_vars = [ ]
-    assignments = { } # pure assignments
+    extensions = []  # extension polynomials
+    extension_vars = []
+    assignments = {}  # pure assignments
 
     # Iterate while polys left
     while polys:
@@ -131,8 +134,8 @@ def extensions_and_assignments(polys):
             # So we can just take the following difference:
 
             value = Polynomial.from_variable_name(var) - poly
-            assert not var in value.variables()
-            assert not var in assignments
+            assert var not in value.variables()
+            assert var not in assignments
             assignments[var] = value
 
         else:
@@ -142,18 +145,19 @@ def extensions_and_assignments(polys):
 
     return extensions, assignments
 
+
 def update_assignments_and_merge(assignments, d):
 
     variables = sorted(set(
             sum([poly.variables() for poly in assignments.values()], [])))
 
-    monomial_to_value = { (): pari(1) }
+    monomial_to_value = {(): pari(1)}
 
     for var in variables:
         max_degree = max([poly.degree(var) for poly in assignments.values()])
 
-        old_keys = list(monomial_to_value.keys())
-        
+        old_keys = list(monomial_to_value)
+
         v = d[var]
         power_of_v = pari(1)
 
@@ -176,15 +180,16 @@ def update_assignments_and_merge(assignments, d):
             [eval_monomial(m) for m in poly.get_monomials()],
             pari(0))
 
-    new_assignments = dict([(key, substitute(poly))
-                            for key, poly in assignments.items()])
+    new_assignments = {key: substitute(poly)
+                            for key, poly in assignments.items()}
 
     # Merge all the assignments of variables
     new_assignments.update(d)
     new_assignments['1'] = pari(1)
-    
+
     return new_assignments
 
+
 def _process_extensions(extensions):
     '''
     Given a tower of field extensions, find the number field defining
@@ -202,7 +207,7 @@ def _process_extensions(extensions):
     # Just rename the variable of the polynomial by x
     ext_assignments = { var: Polynomial.from_variable_name('x') }
     number_field = poly.substitute(ext_assignments)
-    
+
     # Process the other extensions
     # number_field is the polynomial in x defining the number field
     # obtained so far in the tower
@@ -222,16 +227,16 @@ def _process_extensions(extensions):
         # The new number field is again in x but the assignments
         # are assigning polynomials in the old x.
         # Need to update.
-        ext_assignments = dict(
-            [(key, poly.substitute({'x' : old_x_in_new_x}))
-             for key, poly in ext_assignments.items()])
+        ext_assignments = {
+            key: poly.substitute({'x' : old_x_in_new_x})
+             for key, poly in ext_assignments.items()}
 
         # And compute what the root of the last polynomial was
         # to assign it.
         ext_assignments[var] = (
               Polynomial.from_variable_name('x')
             - Polynomial.constant_polynomial(k) * old_x_in_new_x)
-    
+
     return number_field, ext_assignments