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

snappy/snap/character_varieties.py

@@ -1,4 +1,4 @@
-""" 
+"""
 Computing the defining equations of the SL(2, C) character variety
 in terms of the trace coordinates.
 
@@ -11,6 +11,7 @@ from ..pari import pari
 import string
 from itertools import combinations, combinations_with_replacement, product
 
+
 def cycle_sort(l):
     """
     Utility function which takes a list l and returns the minimum
@@ -19,7 +20,7 @@ def cycle_sort(l):
     s = l
     for i in range(0,len(l)):
         temp = l[i:] + l[0:i]
-        if temp<s:
+        if temp < s:
             s = temp
     return s
 
@@ -45,7 +46,7 @@ def pari_poly_variable(variable_name):
     return p
 
 
-class TracePolynomialRing(object):
+class TracePolynomialRing():
     """
     >>> S = TracePolynomialRing('ab')
     >>> S.var_names
@@ -67,18 +68,19 @@ class TracePolynomialRing(object):
         poly_vars = list(gens) + list(combinations(gens, 2))
         poly_vars += list(combinations(gens, 3))
         self.var_names = ['T' + ''.join(v) for v in poly_vars]
-        
+
     def __call__(self, poly):
         return pari(poly)
 
-class Word(object):
+
+class Word():
     """
     The Word class is used to make objects which represent words in a
     free group. The words are represented by a string of letters, with
     capital letters standing for inverses. ex: 'abAB'. The string is
     contained in the 'letters' attribute of the class.
     """
-    
+
     def __init__(self,letters):
         """Creates a Word from a string, automatically reduces"""
         if isinstance(letters, Word):
@@ -180,12 +182,13 @@ class Word(object):
         if len(s) <= 3 and s.islower():
             return pari("T"+s)
 
+
 def tr(w):
     """Shortcut for the SL2_trace method of a word object"""
     return w.SL2_trace()
 
 
-class Presentation(object):
+class Presentation():
     """
     Class representing a presentation of a finitely presented group.
     gens is a list of Word objects representing the generators
@@ -218,6 +221,7 @@ def mult_traceless(a1,a2,a3=None):
                 - pari("1/2")*tr(a2)*tr(a1*a3) - pari("1/2")*tr(a1)*tr(a2*a3)
                 + tr(a1*a2*a3))
 
+
 def s3(a1,a2,a3):
     """
     Accessory function to sum (with sign) "mult_traceless" over all
@@ -227,12 +231,14 @@ def s3(a1,a2,a3):
             + mult_traceless(a3,a1,a2) - mult_traceless(a1,a3,a2)
             - mult_traceless(a3,a2,a1) - mult_traceless(a2,a1,a3))
 
+
 def det(M):
     """Determinant of a 3x3 matrix"""
     return (M[0][0]*M[1][1]*M[2][2] + M[0][1]*M[1][2]*M[2][0]
             + M[1][0]*M[2][1]*M[0][2] - M[0][2]*M[1][1]*M[2][0]
             - M[0][1]*M[1][0]*M[2][2] - M[0][0]*M[1][2]*M[2][1])
 
+
 def rel1(i):
     """Generates type 1 relations for generators (words) i1,i2,i3 j1,j2,j3"""
     [[i1,i2,i3],[j1,j2,j3]] = i
@@ -241,6 +247,7 @@ def rel1(i):
          [mult_traceless(i2,j1),mult_traceless(i2,j2),mult_traceless(i2,j3)],
          [mult_traceless(i3,j1),mult_traceless(i3,j2),mult_traceless(i3,j3)]]))
 
+
 def rel2(j):
     """Generates type 2 relations for generators (words) i,p0,p1,p2,p3"""
     [i,[p0,p1,p2,p3]] = j
@@ -248,6 +255,7 @@ def rel2(j):
             - mult_traceless(i,p1)*s3(p0,p2,p3)
             + mult_traceless(i,p2)*s3(p0,p1,p3) - mult_traceless(i,p3)*s3(p0,p1,p2))
 
+
 def rels_from_rel(R, G):
     """
     Returns the relations in the character variety coming from a relation
@@ -320,20 +328,20 @@ def character_variety(gens, rels=None):
     gens = [Word(gen) for gen in gens]
     rels = [Word(R) for R in rels]
     ring = TracePolynomialRing([g.letters for g in gens])
-    
-    #Type 1
+
+    # Type 1
     triples = list(combinations(gens,3))
     pairsoftriples = list(combinations_with_replacement(triples,2))
 
     t1 = [rel1(i) for i in pairsoftriples]
 
-    #Type 2
+    # Type 2
     fours = list(combinations(gens,4))
     indices = product(gens,fours)
 
     t2 = [rel2(j) for j in indices]
 
-    #Relations from relations
+    # Relations from relations
     r = []
     for R in rels:
         r += rels_from_rel(R,gens)
@@ -351,7 +359,7 @@ def character_variety_ideal(gens, rels=None):
     2
     """
     presentation = character_variety(gens, rels)
-    from sage.all import PolynomialRing, QQ
+    from ..sage_helper import PolynomialRing, QQ
     R = PolynomialRing(QQ, [repr(v) for v in presentation.gens])
     return R.ideal([R(p) for p in presentation.rels])
 
@@ -361,9 +369,7 @@ def total_answer_length(I):
 
 
 if __name__ == "__main__":
-   from snappy.sage_helper import _within_sage, doctest_modules
-   import sys
-   current_module = sys.modules[__name__]
-   doctest_modules([current_module])
-
-   
+    from snappy.testing import doctest_modules
+    import sys
+    current_module = sys.modules[__name__]
+    doctest_modules([current_module])

snappy/snap/find_field.py

@@ -1,10 +1,10 @@
-from __future__ import print_function
-
-from sage.all import (cached_method, real_part, imag_part, round, ceil, floor, log,
-                      ZZ, QQ, CDF, ComplexField, NumberField, PolynomialRing,
-                      matrix, identity_matrix)
 import itertools
 
+from ..sage_helper import (cached_method, real_part, imag_part, round, ceil, floor, log,
+                           ZZ, QQ, CDF, ComplexField, NumberField, PolynomialRing,
+                           matrix, identity_matrix)
+
+
 def error(poly, z, a=ZZ(0)):
     """
     The number of bits above 2^-(precision of z)
@@ -12,20 +12,22 @@ def error(poly, z, a=ZZ(0)):
 
         poly(z) = a
 
-    fails to hold.  
+    fails to hold.
     """
     err = poly(z) - a
     if err == 0:
         return 0
     return z.prec() + ceil(log(abs(poly(z) - a), 2))
 
+
 def acceptable_error(poly, z, a, portion_bad):
     """
-    A error is judged as acceptable if poly(z) = a to within 
+    A error is judged as acceptable if poly(z) = a to within
     2^-(portion_bad*z.prec())
     """
     return error(poly, z, a) <= floor(portion_bad*z.prec())
-    
+
+
 def best_algdep_factor(z, degree):
     if hasattr(z, 'algebraic_dependency'): # Sage >= 8.0
         return z.algebraic_dependency(degree)
@@ -49,11 +51,11 @@ def complex_to_lattice(z, d, a, N=None):
     return A.transpose()
 
 
-class ApproximateAlgebraicNumber(object):
+class ApproximateAlgebraicNumber():
     """
-    An algebraic number which we can compute 
+    An algebraic number which we can compute
     to arbitrary precision.  Specified by a function
-    where f(prec) is the number to 2^prec bits.  
+    where f(prec) is the number to 2^prec bits.
     """
     def __init__(self, defining_function):
         if defining_function in QQ:
@@ -61,9 +63,9 @@ class ApproximateAlgebraicNumber(object):
             defining_function = lambda prec: ComplexField(prec)(x)
         self.f = defining_function
         self._min_poly = None
-        
+
     def __repr__(self):
-        return  '<ApproxAN: %s>' % CDF(self(100))
+        return '<ApproxAN: %s>' % CDF(self(100))
 
     @cached_method
     def __call__(self, prec):
@@ -118,14 +120,14 @@ class ApproximateAlgebraicNumber(object):
 
     def can_express(self, a, prec=None):
         return self.express(a, prec) is not None
-            
+
     def number_field(self):
         p = self._min_poly
         if p is None:
             raise ValueError('Minimal polynomial is not known.')
         q = p.change_ring(QQ)
         q = (1/q.leading_coefficient())*q
-        return NumberField(q, 'z', embedding = self._approx_root)
+        return NumberField(q, 'z', embedding=self._approx_root)
 
     def place(self, prec):
         K = self.number_field()
@@ -136,6 +138,7 @@ class ApproximateAlgebraicNumber(object):
     def __add__(self, other):
         if not isinstance(other, ApproximateAlgebraicNumber):
             raise ValueError
+
         def f(prec):
             return self(prec) + other(prec)
         return ApproximateAlgebraicNumber(f)
@@ -143,6 +146,7 @@ class ApproximateAlgebraicNumber(object):
     def __mul__(self, other):
         if not isinstance(other, ApproximateAlgebraicNumber):
             raise ValueError
+
         def f(prec):
             return self(prec)*other(prec)
         return ApproximateAlgebraicNumber(f)
@@ -150,6 +154,7 @@ class ApproximateAlgebraicNumber(object):
     def __div__(self, other):
         if not isinstance(other, ApproximateAlgebraicNumber):
             raise ValueError
+
         def f(prec):
             return self(prec)/other(prec)
         return ApproximateAlgebraicNumber(f)
@@ -182,10 +187,12 @@ class ExactAlgebraicNumber(ApproximateAlgebraicNumber):
     @cached_method
     def __call__(self, prec):
         roots = [r[0] for r in self._min_poly.roots(ComplexField(prec))]
+
         def dist_to_defining_root(z):
             return abs(z - self._approx_root)
         return sorted(roots, key=dist_to_defining_root)[0]
 
+
 def optimize_field_generator(z):
     p = z.min_polynomial()
     assert p.base_ring() == ZZ
@@ -200,7 +207,8 @@ def optimize_field_generator(z):
     f = f.denominator() * f
     return ExactAlgebraicNumber(f.change_ring(ZZ), w)
 
-class ListOfApproximateAlgebraicNumbers(object):
+
+class ListOfApproximateAlgebraicNumbers():
     def __init__(self, defining_function):
         self.f = defining_function
         self.n = len(defining_function(100))
@@ -209,7 +217,7 @@ class ListOfApproximateAlgebraicNumbers(object):
     @cached_method
     def __call__(self, prec):
         return self.f(prec)
-                 
+
     @cached_method
     def __getitem__(self, index):
         def f(n):
@@ -234,7 +242,7 @@ class ListOfApproximateAlgebraicNumbers(object):
             ans.append(p)
         return ans
 
-    def _find_field_uncached(self, prec, degree, verbosity = False):
+    def _find_field_uncached(self, prec, degree, verbosity=False):
         # Works similar to snap's field::generated_by
         #
         # The input elts is a list of approximate algebraic numbers (i.e., high
@@ -266,7 +274,7 @@ class ListOfApproximateAlgebraicNumbers(object):
         def message(*args):
             if verbosity:
                 print(*args)
-                #assert False
+                # assert False
 
         # The input list
         elts = self.list()
@@ -282,7 +290,7 @@ class ListOfApproximateAlgebraicNumbers(object):
         for i, elt in enumerate(elts):
             # Can the newly considered element elt be expressed in the old z
             exact_elt = z.express(elt, prec)
-            if not exact_elt is None:
+            if exact_elt is not None:
                 # If yes, remember it as its exact representation
                 exact_elts.append(exact_elt)
             else:
@@ -313,19 +321,19 @@ class ListOfApproximateAlgebraicNumbers(object):
                                 return None
                             found, z = True, w
                             break
-                                
+
                 if not found:
                     message("Bailing: Couldn't find primitive element for larger field")
                     return None
-                    
+
         field = z.number_field()
         exact_elts = [field(exact_elt) for exact_elt in exact_elts]
         return field, z, exact_elts
 
-    def find_field(self, prec, degree, optimize=False, verbosity = False):
+    def find_field(self, prec, degree, optimize=False, verbosity=False):
 
         # Adding verbosity for now to debug potential problems
-        
+
         # We always need the unoptimized generator
         if self._field[False] is None:
             self._field[False] = self._find_field_uncached(prec, degree,
@@ -356,16 +364,9 @@ class ListOfApproximateAlgebraicNumbers(object):
         return self._field[optimize]
 
     def _as_exact_matrices(self, optimize=None):
-        if optimize==None:
-            optimize = self._field[True] != None
-        if len(self) % 4 != 0:
+        if optimize is None:
+            optimize = self._field[True] is not None
+        if len(self) % 4:
             raise ValueError("Not right number of values to form 2x2 matrices")
         K, z, ans = self._field[optimize]
         return z, [matrix(K, 2, 2, ans[n:n+4]) for n in range(0, len(ans), 4)]
-        
-
-    
-
-
-    
-