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

snappy/ptolemy/coordinates.py

@@ -1,5 +1,3 @@
-from __future__ import print_function
-
 from .component import ZeroDimensionalComponent
 from .rur import RUR
 from . import matrix
@@ -9,6 +7,7 @@ from ..sage_helper import _within_sage
 from ..pari import Gen, pari
 import re
 
+
 class PtolemyCannotBeCheckedError(Exception):
     def __init__(self):
         msg = (
@@ -17,6 +16,7 @@ class PtolemyCannotBeCheckedError(Exception):
             "class is not supported.")
         Exception.__init__(self, msg)
 
+
 class LogToCloseToBranchCutError(Exception):
     """
     An exception raised when taking log(-x) for some real number x
@@ -25,6 +25,7 @@ class LogToCloseToBranchCutError(Exception):
     """
     pass
 
+
 class RelationViolationError(Exception):
     """
     An exception raised when some supposed relation doesn't hold exactly
@@ -35,7 +36,7 @@ class RelationViolationError(Exception):
         self.value = value
         self.epsilon = epsilon
         self.comment = comment
-    
+
     def __str__(self):
         r = self.comment + " is violated, "
         r += "difference is %s" % self.value
@@ -43,6 +44,7 @@ class RelationViolationError(Exception):
             return r + " (exact values)"
         return r + " (epsilon = %s)" % self.epsilon
 
+
 class NotPU21Representation:
     """
     Returned by is_pu_2_1_representation if cross ratios do not fulfill
@@ -53,26 +55,32 @@ class NotPU21Representation:
 
     def __init__(self, reason):
         self.reason = reason
+
     def __repr__(self):
         return "NotPU21Representation(reason = %r)" % self.reason
 
     def __bool__(self):
         return False
-    
+
     __nonzero__ = __bool__ # backwards compatibility python 2x
 
+
 class NumericalMethodError(Exception):
     def __init__(self, method):
         self.method = method
+
     def __str__(self):
         return "Method %s only supported for numerical values" % self.method
 
+
 class ExactMethodError(Exception):
     def __init__(self, method):
         self.method = method
+
     def __str__(self):
         return "Method %s only supported for exact values" % self.method
 
+
 def _check_relation(value, epsilon, comment):
     if epsilon is None:
         if not value == 0:
@@ -80,7 +88,8 @@ def _check_relation(value, epsilon, comment):
     else:
         if not abs(value) < epsilon:
             raise RelationViolationError(value, epsilon, comment)
-    
+
+
 class PtolemyCoordinates(dict):
     """
     Represents a solution of a Ptolemy variety as python dictionary.
@@ -126,7 +135,7 @@ class PtolemyCoordinates(dict):
 
     >>> old_precision = pari.set_real_precision(100) # with high precision
     >>> numerical_solutions = solution.numerical()
-    
+
     Check that it is a solution, numerically:
 
     >>> numerical_solutions[0].check_against_manifold(M, 1e-80)
@@ -152,7 +161,7 @@ class PtolemyCoordinates(dict):
     True
 
     Compute flattenings:
-    
+
     >>> flattenings = solution.flattenings_numerical()
 
     Compute complex volumes:
@@ -168,14 +177,14 @@ class PtolemyCoordinates(dict):
     >>> normalized = chernSimons * 6 / (pari('Pi')**2)
 
     Check that Chern Simons is zero up to 6 torsion:
-    
+
     >>> normalized - normalized.round() < 1e-9
     True
     """
-        
-    def __init__(self, d, is_numerical = True, py_eval_section = None,
-                 manifold_thunk = lambda : None,
-                 non_trivial_generalized_obstruction_class = False):
+
+    def __init__(self, d, is_numerical=True, py_eval_section=None,
+                 manifold_thunk=lambda : None,
+                 non_trivial_generalized_obstruction_class=False):
 
         self._manifold_thunk = manifold_thunk
 
@@ -186,7 +195,7 @@ class PtolemyCoordinates(dict):
             non_trivial_generalized_obstruction_class)
         processed_dict = d
 
-        if not py_eval_section is None:
+        if py_eval_section is not None:
             # process the extra information that is given by
             # ptolemyVariety's py_eval_section
 
@@ -198,13 +207,13 @@ class PtolemyCoordinates(dict):
         # Caches the matrices that label the short and long edges
         # of the truncated simplices building the manifold
         self._edge_cache = {}
-        
+
         # Caches the images of a fundamental group generator
         self._matrix_cache = []
         self._inverse_matrix_cache = []
 
-        super(PtolemyCoordinates, self).__init__(processed_dict)
-        
+        super().__init__(processed_dict)
+
     def __repr__(self):
         dict_repr = dict.__repr__(self)
         return "PtolemyCoordinates(%s, is_numerical = %r, ...)" % (
@@ -246,17 +255,17 @@ class PtolemyCoordinates(dict):
     def has_obstruction(self):
         """
         Whether the Ptolemy variety has legacy obstruction class that
-        modifies the Ptolemy relation to 
+        modifies the Ptolemy relation to
         """
         N, has_obstruction = _N_and_has_obstruction_for_ptolemys(self)
-        return has_obstruction        
+        return has_obstruction
 
     def number_field(self):
         """
         For an exact solution, return the number_field spanned by the
         Ptolemy coordinates. If number_field is Q, return None.
         """
-        
+
         if self._is_numerical:
             raise ExactMethodError("number_field")
 
@@ -273,7 +282,7 @@ class PtolemyCoordinates(dict):
         >>> solution = solutions[2]
 
         Turn into a numerical solution:
-        
+
         >>> old_precision = pari.set_real_precision(100) # with high precision
         >>> numerical_solutions = solution.numerical()
         >>> pari.set_real_precision(old_precision) # reset pari engine
@@ -284,38 +293,36 @@ class PtolemyCoordinates(dict):
         >>> numerical_solution = numerical_solutions[0]
         >>> value = numerical_solution['c_1110_0']
         """
-        
+
         if self._is_numerical:
             return self
         return ZeroDimensionalComponent(
             [ PtolemyCoordinates(
-                    d, is_numerical = True,
-                    manifold_thunk = self._manifold_thunk,
-                    non_trivial_generalized_obstruction_class = (
+                    d, is_numerical=True,
+                    manifold_thunk=self._manifold_thunk,
+                    non_trivial_generalized_obstruction_class=(
                         self._non_trivial_generalized_obstruction_class))
               for d in _to_numerical(self) ])
 
     def to_PUR(self):
-
         """
         If any Ptolemy coordinates are given as Rational Univariate
         Representation, convert them to Polynomial Univariate Representation and
         return the result.
-        
+
         See to_PUR of RUR.
 
         This conversion might lead to very large coefficients.
         """
-        
+
         return PtolemyCoordinates(
             _apply_to_RURs(self, RUR.to_PUR),
-            is_numerical = self._is_numerical,
-            manifold_thunk = self._manifold_thunk,
-            non_trivial_generalized_obstruction_class = (
+            is_numerical=self._is_numerical,
+            manifold_thunk=self._manifold_thunk,
+            non_trivial_generalized_obstruction_class=(
                 self._non_trivial_generalized_obstruction_class))
 
     def multiply_terms_in_RUR(self):
-        
         """
         If a Ptolemy coordinate is given as Rational Univariate Representation
         with numerator and denominator being a product, multiply the terms and
@@ -329,13 +336,12 @@ class PtolemyCoordinates(dict):
 
         return PtolemyCoordinates(
             _apply_to_RURs(self, RUR.multiply_terms),
-            is_numerical = self._is_numerical,
-            manifold_thunk = self._manifold_thunk,
-            non_trivial_generalized_obstruction_class = (
+            is_numerical=self._is_numerical,
+            manifold_thunk=self._manifold_thunk,
+            non_trivial_generalized_obstruction_class=(
                 self._non_trivial_generalized_obstruction_class))
 
     def multiply_and_simplify_terms_in_RUR(self):
-
         """
         If a Ptolemy coordinate is given as Rational Univariate Representation
         with numerator and denominator being a product, multiply the terms,
@@ -347,31 +353,31 @@ class PtolemyCoordinates(dict):
         factorised.
 
         """
-        
+
         return PtolemyCoordinates(
             _apply_to_RURs(self, RUR.multiply_and_simplify_terms),
-            is_numerical = self._is_numerical,
-            manifold_thunk = self._manifold_thunk,
-            non_trivial_generalized_obstruction_class = (
-                self._non_trivial_generalized_obstruction_class))    
+            is_numerical=self._is_numerical,
+            manifold_thunk=self._manifold_thunk,
+            non_trivial_generalized_obstruction_class=(
+                self._non_trivial_generalized_obstruction_class))
 
     def cross_ratios(self):
         """
         Compute cross ratios from Ptolemy coordinates. The cross ratios are
         according to the SnapPy convention, so we have::
-        
+
              z = 1 - 1/zp, zp = 1 - 1/zpp, zpp = 1 - 1/z
-             
+
         where::
-        
+
              z   is at the edge 01 and equal to   s0 * s1 * (c_1010 * c_0101) / (c_1001 * c_0110)
              zp  is at the edge 02 and equal to - s0 * s2 * (c_1001 * c_0110) / (c_1100 * c_0011)
              zpp is at the edge 03 and equal to   s0 * s3 * (c_1100 * c_0011) / (c_0101 * c_1010).
 
-        Note that this is different from the convention used in 
+        Note that this is different from the convention used in
         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
 
         Take an exact solution:
 
@@ -382,14 +388,14 @@ class PtolemyCoordinates(dict):
         Turn into cross Ratios:
 
         >>> crossRatios = solution.cross_ratios()
-        
+
         Get a cross ratio:
-        
+
         >>> crossRatios['zp_0010_0']
         Mod(-x, x^2 + x + 1)
 
         Check the relationship between cross ratios:
-        
+
         >>> crossRatios['z_0010_0'] == 1 - 1 / crossRatios['zp_0010_0']
         True
 
@@ -402,15 +408,15 @@ class PtolemyCoordinates(dict):
         Get information about what one can do with cross ratios
         """
         return CrossRatios(_ptolemy_to_cross_ratio(self)[0],
-                           is_numerical = self._is_numerical,
-                           manifold_thunk = self._manifold_thunk)
+                           is_numerical=self._is_numerical,
+                           manifold_thunk=self._manifold_thunk)
 
     def cross_ratios_numerical(self):
         """
         Turn exact solutions into numerical and then compute cross ratios.
         See numerical() and cross_ratios().
         """
-        
+
         if self._is_numerical:
             return self.cross_ratios()
         else:
@@ -419,7 +425,7 @@ class PtolemyCoordinates(dict):
 
     def flattenings_numerical(self):
         """
-        Turn into numerical solutions and compute flattenings, see 
+        Turn into numerical solutions and compute flattenings, see
         help(snappy.ptolemy.coordinates.Flattenings)
         Also see numerical()
 
@@ -429,7 +435,7 @@ class PtolemyCoordinates(dict):
         >>> solutions = solutions_from_magma(_magma_output_for_4_1__sl3)
         >>> solution = solutions[2]
 
-        Compute a numerical soluton
+        Compute a numerical solution
 
         >>> flattenings = solution.flattenings_numerical()
 
@@ -445,17 +451,17 @@ class PtolemyCoordinates(dict):
             for i in range(1000):
                 try:
                     # get the dictionary containing flattenings
-                    # and the evenN that describes in what 
+                    # and the evenN that describes in what
                     # flavor of the Extended Bloch group the result lives in
                     d, evenN = _ptolemy_to_cross_ratio(
                         self,
                         branch_factor,
                         self._non_trivial_generalized_obstruction_class,
-                        as_flattenings = True)
+                        as_flattenings=True)
 
                     return Flattenings(d,
-                                       manifold_thunk = self._manifold_thunk,
-                                       evenN = evenN)
+                                       manifold_thunk=self._manifold_thunk,
+                                       evenN=evenN)
                 except LogToCloseToBranchCutError:
                     # Values to close to the branch cut, just multiply
                     # by a small offset
@@ -466,7 +472,7 @@ class PtolemyCoordinates(dict):
             return ZeroDimensionalComponent(
                 [num.flattenings_numerical() for num in self.numerical()])
 
-    def volume_numerical(self, drop_negative_vols = False):
+    def volume_numerical(self, drop_negative_vols=False):
         """
         Turn into (Galois conjugate) numerical solutions and compute volumes.
         If already numerical, only return the one volume.
@@ -485,8 +491,8 @@ class PtolemyCoordinates(dict):
             return vols
 
     def complex_volume_numerical(self,
-                                 drop_negative_vols = False,
-                                 with_modulo = False):
+                                 drop_negative_vols=False,
+                                 with_modulo=False):
         """
         Turn into (Galois conjugate) numerical solutions and compute complex
         volumes. If already numerical, return the volume.
@@ -496,14 +502,14 @@ class PtolemyCoordinates(dict):
         See numerical(). If drop_negative_vols = True is given as optional
         argument, only return complex volumes with non-negative real part.
         """
-        
+
         if self._is_numerical:
             return self.flattenings_numerical().complex_volume(
-                with_modulo = with_modulo)
+                with_modulo=with_modulo)
         else:
             cvols = ZeroDimensionalComponent(
                 [ num.flattenings_numerical().complex_volume(
-                        with_modulo = with_modulo)
+                        with_modulo=with_modulo)
                   for num in self.numerical()])
             if drop_negative_vols:
                 return [cvol for cvol in cvols if cvol.real() > -1e-12]
@@ -556,10 +562,10 @@ class PtolemyCoordinates(dict):
 
         See Definition 10.1:
         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
         """
-        
+
         # Integral points that are indices of Ptolemy coordinates
         pt_v0_v0 = [ a + 2 * _kronecker_delta(v0, i)
                           for i, a in enumerate(pt) ]
@@ -580,14 +586,14 @@ class PtolemyCoordinates(dict):
         # See Definition 9.23 of
         # Garoufalidis, Thurston, Zickert
         # The Complex Volume of SL(n,C)-Representations of 3-Manifolds
-        # http://arxiv.org/abs/1111.2828
-        face = list(set(range(4)) - set([v0, v1, v2]))[0]
+        # httpss://arxiv.org/abs/1111.2828
+        face = next(iter(set(range(4)) - {v0, v1, v2}))
         obstruction = self._get_obstruction_variable(face, tet)
 
         # The epsilon permutation sign from Definition 10.1 of
         # 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
         s = PtolemyCoordinates._three_perm_sign(v0, v1, v2)
 
         # The equation from the same Definition
@@ -595,7 +601,6 @@ class PtolemyCoordinates(dict):
                   (c_pt_v0_v0 * c_pt_v1_v2) /
                   (c_pt_v0_v1 * c_pt_v0_v2))
 
-
     def ratio_coordinate(self, tet, v0, v1, pt):
         """
         Returns the ratio coordinate for tetrahedron with index tet
@@ -604,8 +609,8 @@ class PtolemyCoordinates(dict):
 
         See Definition 10.2:
         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
 
         Note that this definition turned out to have the wrong sign. Multiply
         the result by -1 if v1 < v0 and N is even.
@@ -632,7 +637,7 @@ class PtolemyCoordinates(dict):
 
         # Get N
         N = self.N()
-        
+
         return [[_kronecker_delta(i, j) for i in range(N)] for j in range(N)]
 
     def long_edge(self, tet, v0, v1, v2):
@@ -644,8 +649,8 @@ class PtolemyCoordinates(dict):
         This matrix was labeled alpha^{v0v1v2} (v2 does not matter for non
         double-truncated simplex) in Figure 18 of
         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
 
         It is computed using equation 10.4. Note that the ratio coordinate
         is different from the definition in the paper (see ratio_coordinate).
@@ -657,7 +662,7 @@ class PtolemyCoordinates(dict):
         key = 'long_%d_%d%d' % (tet, v0, v1)
 
         # Fill cache if necessary
-        if not key in self._edge_cache:
+        if key not in self._edge_cache:
 
             # Get N
             N = self.N()
@@ -688,8 +693,8 @@ class PtolemyCoordinates(dict):
 
         This matrix was labeled beta^{v0v1v2} in Figure 18 of
         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
 
         It is computed using equation 10.4.
 
@@ -700,21 +705,21 @@ class PtolemyCoordinates(dict):
         key = 'middle_%d_%d%d%d' % (tet, v0, v1, v2)
 
         # Fill cache if necessary
-        if not key in self._edge_cache:
+        if key not in self._edge_cache:
 
             # Get N
             N = self.N()
 
             # Start with identity
             m = self._get_identity_matrix()
-            
+
             # Compute the product in equation 10.4
             for a0, a1, a2 in utilities.triples_with_fixed_sum_iterator(N - 2):
-                
+
                 # Get integral point for diamond coordinate
                 pt = [ a1 * _kronecker_delta(v0, i) +
                        a2 * _kronecker_delta(v1, i) +
-                       a0 * _kronecker_delta(v2, i)    for i in range(4) ]
+                       a0 * _kronecker_delta(v2, i) for i in range(4) ]
 
                 # Compute diamond coordinate
                 diamond = self.diamond_coordinate(tet, v0, v1, v2, pt)
@@ -734,18 +739,18 @@ class PtolemyCoordinates(dict):
         can be though of as doubly truncated simplices where all short edges
         are collapsed, hence labeled by the identity.
 
-        See equation 10.4 in 
+        See equation 10.4 in
         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
         """
 
         # Key for the cache
         key = 'short'
 
         # Fill cache if necessary
-        if not key in self._edge_cache:
-            
+        if key not in self._edge_cache:
+
             # Get N
             N = self.N()
 
@@ -762,7 +767,7 @@ class PtolemyCoordinates(dict):
         # fundamental group generators and their inverses
 
         if self._matrix_cache and self._inverse_matrix_cache:
-            return 
+            return
 
         # Compute all the matrices for the generators and there inverses
         # The short edges of the doubly truncated simplices are all identities
@@ -770,9 +775,9 @@ class PtolemyCoordinates(dict):
         # no penalty.
         self._matrix_cache, self._inverse_matrix_cache = (
             findLoops.images_of_original_generators(self,
-                                                    penalties = (0, 1, 1)))
+                                                    penalties=(0, 1, 1)))
 
-    def evaluate_word(self, word, G = None):
+    def evaluate_word(self, word, G=None):
         """
         Given a word in the generators of the fundamental group,
         compute the corresponding matrix. By default, these are the
@@ -797,7 +802,7 @@ class PtolemyCoordinates(dict):
             G)
 
     def _testing_assert_identity(self, m,
-                                 allow_sign_if_obstruction_class = False):
+                                 allow_sign_if_obstruction_class=False):
 
         N = self.N()
 
@@ -836,17 +841,17 @@ class PtolemyCoordinates(dict):
                 m2 = self.long_edge(tet,v[1],v[0],v[2])
                 self._testing_assert_identity(
                     matrix.matrix_mult(m1, m2))
-                
+
             # Check triangle for each vertex
             for v in [(0,1,2,3), (1,2,3,0), (2,3,0,1), (3,0,1,2)]:
                 m1 = self.middle_edge(tet, v[0], v[1], v[2])
                 m2 = self.middle_edge(tet, v[0], v[2], v[3])
                 m3 = self.middle_edge(tet, v[0], v[3], v[1])
-                
+
                 self._testing_assert_identity(
                     matrix.matrix_mult(
                         m1, matrix.matrix_mult(m2, m3)))
-                
+
             # Check hexagon for each face
             for v in [(0,1,2), (0,1,3), (0,2,3), (1,2,3)]:
                 m1 = self.middle_edge(tet,v[0],v[1],v[2])
@@ -866,8 +871,7 @@ class PtolemyCoordinates(dict):
                                     m4,
                                     matrix.matrix_mult(m5,m6))))), True)
 
-
-    def check_against_manifold(self, M = None, epsilon = None):
+    def check_against_manifold(self, M=None, epsilon=None):
         """
         Checks that the given solution really is a solution to the Ptolemy
         variety of a manifold. See help(ptolemy.PtolemyCoordinates) for
@@ -930,12 +934,11 @@ class PtolemyCoordinates(dict):
                     key = "c_%d%d%d%d" % tuple(total_index) + "_%d" % tet
                     return self[key]
 
-
                 s0 = self._get_obstruction_variable(0, tet)
                 s1 = self._get_obstruction_variable(1, tet)
                 s2 = self._get_obstruction_variable(2, tet)
                 s3 = self._get_obstruction_variable(3, tet)
-                    
+
                 rel = (  s0 * s1 * get_ptolemy_coordinate((1,1,0,0))
                                  * get_ptolemy_coordinate((0,0,1,1))
                        - s0 * s2 * get_ptolemy_coordinate((1,0,1,0))
@@ -947,7 +950,7 @@ class PtolemyCoordinates(dict):
                                 epsilon,
                                 "Ptolemy relation")
 
-    def is_geometric(self, epsilon = 1e-6):
+    def is_geometric(self, epsilon=1e-6):
         """
         Returns true if all shapes corresponding to this solution have positive
         imaginary part.
@@ -974,19 +977,19 @@ class Flattenings(dict):
 
     We assign to each pair of parallel edges of each simplex a triple (w, z, p)
     such that::
-    
+
            w = log(z) + p * (2 * pi * i / N)   where N is fixed and even.
-           
+
     For N = 2, the three triples belonging to a simplex form a combinatorial
     flattening (w0, w1, w2) as defined in Definition 3.1 in
     Walter D. Neumann, Extended Bloch group and the Cheeger-Chern-Simons class
-    http://arxiv.org/abs/math.GT/0307092
+    https://arxiv.org/abs/math.GT/0307092
 
     For N > 2, the three triples form a generalized combinatorial flattening
     (w0, w1, w2) that gives an element in the generalized Extended Bloch group
     which is the Extended Bloch group corresponding to the Riemann surface
     given by::
-    
+
                  u1 * e^w0 + u2 * e^w1 = 1
 
     where u1^N = u2^N = 1.
@@ -999,14 +1002,14 @@ class Flattenings(dict):
     This work has not been published yet.
 
     If f is a flattening, then in the notation of Neumann, the value of::
-    
+
         f['z_xxxx_y']    is (w0, z, p)
         f['zp_xxxx_y']   is (w1, z', q)
         f['zpp_xxxx_y']  is (w2, z'', r).
     """
-        
-    def __init__(self, d, manifold_thunk = lambda : None, evenN = 2):
-        super(Flattenings, self).__init__(d)
+
+    def __init__(self, d, manifold_thunk=lambda : None, evenN=2):
+        super().__init__(d)
         self._is_numerical = True
         self._manifold_thunk = manifold_thunk
         self.dimension = 0
@@ -1050,7 +1053,6 @@ class Flattenings(dict):
 
     @classmethod
     def from_tetrahedra_shapes_of_manifold(cls, M):
-
         """
         Takes as argument a manifold and produces (weak) flattenings using
         the tetrahedra_shapes of the manifold M.
@@ -1067,7 +1069,7 @@ class Flattenings(dict):
         num_tets = M.num_tetrahedra()
 
         z_cross_ratios = M.tetrahedra_shapes(
-            part='rect', dec_prec = pari.get_real_precision())
+            part='rect', dec_prec=pari.get_real_precision())
 
         all_cross_ratios = sum(
             [ [z, 1 / (1-z), 1 - 1/z] for z in z_cross_ratios], [])
@@ -1075,9 +1077,9 @@ class Flattenings(dict):
         log_all_cross_ratios = [ z.log() for z in all_cross_ratios ]
 
         def flattening_condition(r):
-            return (   3 *                 r  * [0]
-                     + 3 *                      [1]
-                     + 3 * (num_tets - r - 1) * [0])
+            return (3 * r * [0]
+                    + 3 * [1]
+                    + 3 * (num_tets - r - 1) * [0])
 
         flattening_conditions = [
             flattening_condition(r) for r in range(num_tets)]
@@ -1095,11 +1097,11 @@ class Flattenings(dict):
         extra_cols = len(all_equations[0]) - len(all_equations)
 
         d = [d_mat[r][r + extra_cols] for r in range(len(d_mat))]
-        
+
         # errors to the gluing equations and flattening condition
         # when using the logarithms without adding p * pi * i as complex
         # numbers
-        errors = matrix.matrix_mult_vector(all_equations, 
+        errors = matrix.matrix_mult_vector(all_equations,
                                            log_all_cross_ratios)
 
         # divide by pi * i and turn into integers
@@ -1121,7 +1123,7 @@ class Flattenings(dict):
 
         flattenings = matrix.matrix_mult_vector(v, flattenings_in_other_basis)
 
-        assert (matrix.matrix_mult_vector(all_equations, flattenings) == 
+        assert (matrix.matrix_mult_vector(all_equations, flattenings) ==
                 [-x for x in int_errors])
 
         keys = sum([ ['z_0000_%d' % i,
@@ -1129,12 +1131,12 @@ class Flattenings(dict):
                       'zpp_0000_%d' % i] for i in range(num_tets)],[])
 
         Mcopy = M.copy()
-        
+
         return Flattenings(
-            dict([ (k, (log + PiI * p, z, p))
+            {k: (log + PiI * p, z, p)
                    for k, log, z, p in zip(keys, log_all_cross_ratios,
-                                           all_cross_ratios, flattenings)]),
-            manifold_thunk = lambda : Mcopy)
+                                           all_cross_ratios, flattenings)},
+            manifold_thunk=lambda : Mcopy)
 
     def get_order(self):
         """
@@ -1146,24 +1148,23 @@ class Flattenings(dict):
         return self._evenN
 
     def get_zpq_triple(self, key_z):
-
         """
         Gives a flattening as triple [z;p,q] representing an element
         in the generalized Extended Bloch group similar to the way the
-        triple [z;p,q] is used in Lemma 3.2 in 
+        triple [z;p,q] is used in Lemma 3.2 in
         Walter D. Neumann, Extended Bloch group and the Cheeger-Chern-Simons class
-        http://arxiv.org/abs/math.GT/0307092
+        https://arxiv.org/abs/math.GT/0307092
         """
         if not key_z[:2] == 'z_':
             raise Exception("Need to be called with cross ratio variable z_....")
         key_zp = 'zp_' + key_z[2:]
-        
-        w,  z,  p = self[key_z]
+
+        w, z, p = self[key_z]
         wp, zp, q_canonical_branch_cut = self[key_zp]
 
         # Note that the q in l(z;p,q) and in Definition 3.1 are different if
         # z is on the real axis and > 1!!!
-        # Thus we need to compute the q again here according to the formula 
+        # Thus we need to compute the q again here according to the formula
         # for l(z;p,q)
 
         pari_z = _convert_to_pari_float(z)
@@ -1174,7 +1175,7 @@ class Flattenings(dict):
 
         return (z, p, q_dilog_branch_cut)
 
-    def complex_volume(self, with_modulo = False):
+    def complex_volume(self, with_modulo=False):
         """
         Compute complex volume. The complex volume is defined only up to
         some multiple of m where m = i * pi**2/6 for PSL(2,C) and SL(N,C)
@@ -1197,8 +1198,8 @@ class Flattenings(dict):
                 if key[:2] == 'z_' ])
 
         cvol = sum_L_functions / pari('I')
-        vol  = cvol.real()
-        cs   = cvol.imag() % m
+        vol = cvol.real()
+        cs = cvol.imag() % m
 
         if cs > m/2 + pari('1e-12'):
             cs = cs - m
@@ -1206,17 +1207,17 @@ class Flattenings(dict):
         cvol = vol + cs * pari('I')
 
         if with_modulo:
-            if not self._evenN in [2, 6]:
+            if self._evenN not in [2, 6]:
                 raise Exception("Unknown torsion")
 
             return cvol, m * pari('I')
         return cvol
 
-    def check_against_manifold(self, M = None, epsilon = 1e-10):
+    def check_against_manifold(self, M=None, epsilon=1e-10):
         """
         Checks that the flattening really is a solution to the logarithmic
-        PGL(N,C) gluing equations of a manifold. Usage similar to 
-        check_against_manifold of Ptolemy Coordinates, see 
+        PGL(N,C) gluing equations of a manifold. Usage similar to
+        check_against_manifold of Ptolemy Coordinates, see
         help(ptolemy.Coordinates) for similar examples.
 
         === Arguments ===
@@ -1237,28 +1238,28 @@ class Flattenings(dict):
             _check_relation(
                 w - (z.log() + f * p),
                 epsilon,
-                "Flattening relation w != log(z) + PiI * p")
+                "Flattening relation w == log(z) + PiI * p")
 
         for k in list(self.keys()):
             if k[:2] == 'z_':
-                w,   z,   p = self[k]
-                wp,  zp,  q = self['zp_'+k[2:]]
+                w, z, p = self[k]
+                wp, zp, q = self['zp_'+k[2:]]
                 wpp, zpp, r = self['zpp_'+k[2:]]
                 _check_relation(
                     w + wp + wpp,
                     epsilon,
-                    "Flattening relation w0 + w1 + w2 != 0")
+                    "Flattening relation w0 + w1 + w2 == 0")
 
         some_z = list(self.keys())[0]
         variable_name, index, tet_index = some_z.split('_')
-        if not variable_name in ['z', 'zp', 'zpp']:
+        if variable_name not in ['z', 'zp', 'zpp']:
             raise Exception("Variable not z, zp, or, zpp")
-        if not len(index) == 4:
+        if len(index) != 4:
             raise Exception("Not 4 indices")
         N = sum([int(x) for x in index]) + 2
 
         matrix_with_explanations = M.gluing_equations_pgl(
-            N, equation_type = 'all')
+            N, equation_type='all')
 
         matrix = matrix_with_explanations.matrix
         rows = matrix_with_explanations.explain_rows
@@ -1275,35 +1276,36 @@ class Flattenings(dict):
                 epsilon,
                 "Gluing equation %s" % rows[row])
 
-class CrossRatios(dict): 
+
+class CrossRatios(dict):
     """
     Represents assigned shape parameters/cross ratios as
     dictionary. The cross ratios are according to SnapPy convention, so we
     have::
-    
+
         z = 1 - 1/zp, zp = 1 - 1/zpp, zpp = 1 - 1/z
-        
+
     where::
-    
+
         z   is at the edge 01 and equal to s0 * s1 * (c_1010 * c_0101) / (c_1001 * c_0110)
         zp  is at the edge 02 and equal to s0 * s2 * (c_1001 * c_0110) / (c_1100 * c_0011)
         zpp is at the edge 03 and equal to s0 * s3 * (c_1100 * c_0011) / (c_0101 * c_1010).
 
-    Note that this is different from the convention used in 
+    Note that this is different from the convention used in
     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
     """
-    
-    def __init__(self, d, is_numerical = True, manifold_thunk = None):
-        super(CrossRatios, self).__init__(d)
+
+    def __init__(self, d, is_numerical=True, manifold_thunk=None):
+        super().__init__(d)
         self._is_numerical = is_numerical
         self._manifold_thunk = manifold_thunk
 
         # Caches the matrices that label the short and long edges
         # of the truncated simplices building the manifold
         self._edge_cache = {}
-        
+
         # Caches the images of a fundamental group generator
         self._matrix_cache = []
         self._inverse_matrix_cache = []
@@ -1311,25 +1313,25 @@ class CrossRatios(dict):
         self.dimension = 0
 
     @staticmethod
-    def from_snappy_manifold(M, dec_prec = None, bits_prec = None,
-                             intervals = False):
+    def from_snappy_manifold(M, dec_prec=None, bits_prec=None,
+                             intervals=False):
         """
         Constructs an assignment of shape parameters/cross ratios using
         the tetrahehdra_shapes method of a given SnapPy manifold. The optional
         parameters are the same as that of tetrahedra_shapes.
         """
 
-        shapes = M.tetrahedra_shapes('rect', dec_prec = dec_prec,
-                                     bits_prec = bits_prec,
-                                     intervals = intervals)
+        shapes = M.tetrahedra_shapes('rect', dec_prec=dec_prec,
+                                     bits_prec=bits_prec,
+                                     intervals=intervals)
         d = {}
         for i, shape in enumerate(shapes):
             d['z_0000_%d' % i] = shape
             d['zp_0000_%d' % i] = 1 / (1 - shape)
             d['zpp_0000_%d' % i] = 1 - 1 / shape
-        
-        return CrossRatios(d, is_numerical = True,
-                           manifold_thunk = lambda M = M: M)
+
+        return CrossRatios(d, is_numerical=True,
+                           manifold_thunk=lambda M=M: M)
 
     def __repr__(self):
         dict_repr = dict.__repr__(self)
@@ -1374,33 +1376,31 @@ class CrossRatios(dict):
         Turn exact solutions into numerical solutions using pari. Similar to
         numerical() of PtolemyCoordinates. See help(ptolemy.PtolemyCoordinates)
         for example.
-        """        
+        """
         if self._is_numerical:
             return self
         return ZeroDimensionalComponent([
-            CrossRatios(d, is_numerical = True,
-                        manifold_thunk = self._manifold_thunk)
+            CrossRatios(d, is_numerical=True,
+                        manifold_thunk=self._manifold_thunk)
             for d in _to_numerical(self) ])
 
     def to_PUR(self):
-        
         """
         If any Ptolemy coordinates are given as Rational Univariate
         Representation, convert them to Polynomial Univariate Representation and
         return the result.
 
         See to_PUR of RUR.
-        
+
         This conversion might lead to very large coefficients.
         """
 
         return CrossRatios(
             _apply_to_RURs(self, RUR.to_PUR),
-            is_numerical = self._is_numerical,
-            manifold_thunk = self._manifold_thunk)
+            is_numerical=self._is_numerical,
+            manifold_thunk=self._manifold_thunk)
 
     def multiply_terms_in_RUR(self):
-
         """
         If a cross ratio is given as Rational Univariate Representation
         with numerator and denominator being a product, multiply the terms and
@@ -1411,14 +1411,13 @@ class CrossRatios(dict):
         This loses information about how the numerator and denominator are
         factorised.
         """
-        
+
         return CrossRatios(
             _apply_to_RURs(self, RUR.multiply_terms),
-            is_numerical = self._is_numerical,
-            manifold_thunk = self._manifold_thunk)
+            is_numerical=self._is_numerical,
+            manifold_thunk=self._manifold_thunk)
 
     def multiply_and_simplify_terms_in_RUR(self):
-
         """
         If a cross ratio is given as Rational Univariate Representation
         with numerator and denominator being a product, multiply the terms,
@@ -1430,13 +1429,13 @@ class CrossRatios(dict):
         factorised.
 
         """
-        
+
         return CrossRatios(
             _apply_to_RURs(self, RUR.multiply_and_simplify_terms),
-            is_numerical = self._is_numerical,
-            manifold_thunk = self._manifold_thunk)
+            is_numerical=self._is_numerical,
+            manifold_thunk=self._manifold_thunk)
 
-    def volume_numerical(self, drop_negative_vols = False):
+    def volume_numerical(self, drop_negative_vols=False):
         """
         Turn into (Galois conjugate) numerical solutions and compute volumes.
         If already numerical, only compute the one volume.
@@ -1475,8 +1474,8 @@ class CrossRatios(dict):
         and the conventions in Definition 4.2 of
 
         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
         """
 
         postfix = '_%d%d%d%d' % tuple(pt) + '_%d' % tet
@@ -1486,7 +1485,7 @@ class CrossRatios(dict):
 
         if tuple(edge) in [(1,0,1,0), (0,1,0,1)]:
             return self['zp' + postfix]
-        
+
         if tuple(edge) in [(1,0,0,1), (0,1,1,0)]:
             return self['zpp' + postfix]
 
@@ -1499,8 +1498,8 @@ class CrossRatios(dict):
 
         See Definition 10.9:
         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
         """
 
         result = 1
@@ -1508,7 +1507,7 @@ class CrossRatios(dict):
         for v0 in range(4):
             for v1 in range(v0 + 1, 4):
                 e = [ _kronecker_delta(v0, i) +
-                      _kronecker_delta(v1, i)   for i in range(4) ]
+                      _kronecker_delta(v1, i) for i in range(4) ]
                 p = [ x1 - x2 for x1, x2 in zip(pt, e) ]
                 if all(x >= 0 for x in p):
                     result *= self._shape_at_tet_point_and_edge(tet, p, e)
@@ -1519,7 +1518,7 @@ class CrossRatios(dict):
 
         # Get N
         N = self.N()
-        
+
         return [[_kronecker_delta(i, j) for i in range(N)] for j in range(N)]
 
     def long_edge(self, tet, v0, v1, v2):
@@ -1530,30 +1529,30 @@ class CrossRatios(dict):
 
         This matrix was labeled alpha^{v0v1v2} in Figure 18 of
         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
 
         It is computed using equation 10.22.
-        
+
         The resulting matrix is given as a python list of lists.
         """
-        
+
         # Key for cache
         key = 'long_edge'
 
         # Fill cache if necessary
-        if not key in self._edge_cache:
-            
+        if key not in self._edge_cache:
+
             # Get N
             N = self.N()
-            
+
             # It is just the counter diagonal matrix
             m = [ [ _kronecker_delta(i+j, N-1) for i in range(N) ]
                   for j in range(N)]
 
             # Set in cache
             self._edge_cache[key] = m
-            
+
         return self._edge_cache[key]
 
     def middle_edge(self, tet, v0, v1, v2):
@@ -1564,11 +1563,11 @@ class CrossRatios(dict):
 
         This matrix was labeled beta^{v0v1v2} in Figure 18 of
         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
 
         It is computed using equation 10.22.
-        
+
         The resulting matrix is given as a python list of lists.
         """
 
@@ -1576,7 +1575,7 @@ class CrossRatios(dict):
         key = 'middle_%d_%d%d%d' % (tet, v0, v1, v2)
 
         # Fill cache if necessary
-        if not key in self._edge_cache:
+        if key not in self._edge_cache:
 
             # Get N
             N = self.N()
@@ -1592,7 +1591,7 @@ class CrossRatios(dict):
                 prod1 = self._get_identity_matrix()
                 for i in range(1, N - k + 1):
                     prod1 = matrix.matrix_mult(prod1, _X(N, i, 1))
-                    
+
                 # Compute second product
                 prod2 = self._get_identity_matrix()
                 for i in range(1, N - k):
@@ -1618,10 +1617,10 @@ class CrossRatios(dict):
                     for j in range(N) ]
 
             m = matrix.matrix_mult(m, dpm)
-                
+
             # Set in cache
             self._edge_cache[key] = m
-            
+
         return self._edge_cache[key]
 
     def short_edge(self, tet, v0, v1, v2):
@@ -1632,11 +1631,11 @@ class CrossRatios(dict):
 
         This matrix was labeled gamma^{v0v1v2} in Figure 18 of
         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
 
         It is computed using equation 10.22.
-        
+
         The resulting matrix is given as a python list of lists.
         """
 
@@ -1644,10 +1643,10 @@ class CrossRatios(dict):
         key = 'short_%d_%d%d%d' % (tet, v0, v1, v2)
 
         # Fill cache if necessary
-        if not key in self._edge_cache:
+        if key not in self._edge_cache:
 
             edge = [ _kronecker_delta(v0, i) +
-                     _kronecker_delta(v1, i)   for i in range(4) ]
+                     _kronecker_delta(v1, i) for i in range(4) ]
 
             # The epsilon permutation sign
             sgn = CrossRatios._cyclic_three_perm_sign(v0, v1, v2)
@@ -1662,12 +1661,12 @@ class CrossRatios(dict):
             for a0 in range(N-1):
                 a1 = N - 2 - a0
                 pt = [ a0 * _kronecker_delta(v0, i) +
-                       a1 * _kronecker_delta(v1, i)   for i in range(4) ]
+                       a1 * _kronecker_delta(v1, i) for i in range(4) ]
 
                 cross_ratio = self._shape_at_tet_point_and_edge(tet, pt, edge)
 
                 # Multiply result with the H matrix
-                
+
                 # Note that the sgn is different from the paper
                 # because we are using SnapPy conventions for
                 # cross ratios here
@@ -1684,7 +1683,7 @@ class CrossRatios(dict):
         # fundamental group generators and their inverses
 
         if self._matrix_cache and self._inverse_matrix_cache:
-            return 
+            return
 
         # Compute all the matrices for the generators and there inverses
         # The long edges of the doubly truncated simplex are all unit
@@ -1692,9 +1691,9 @@ class CrossRatios(dict):
         # size of any polynomial coefficients. We thus don't give them penalty.
         self._matrix_cache, self._inverse_matrix_cache = (
             findLoops.images_of_original_generators(self,
-                                                    penalties = (0, 1, 1)))
+                                                    penalties=(0, 1, 1)))
 
-    def evaluate_word(self, word, G = None):
+    def evaluate_word(self, word, G=None):
         """
         Given a word in the generators of the fundamental group,
         compute the corresponding matrix. By default, these are the
@@ -1718,7 +1717,7 @@ class CrossRatios(dict):
             word,
             G)
 
-    def check_against_manifold(self, M = None, epsilon = None):
+    def check_against_manifold(self, M=None, epsilon=None):
         """
         Checks that the given solution really is a solution to the PGL(N,C) gluing
         equations of a manifold. Usage similar to check_against_manifold of
@@ -1738,14 +1737,14 @@ class CrossRatios(dict):
 
         some_z = list(self.keys())[0]
         variable_name, index, tet_index = some_z.split('_')
-        if not variable_name in ['z', 'zp', 'zpp']:
+        if variable_name not in ['z', 'zp', 'zpp']:
             raise Exception("Variable not z, zp, or, zpp")
-        if not len(index) == 4:
+        if len(index) != 4:
             raise Exception("Not 4 indices")
         N = sum([int(x) for x in index]) + 2
-        
+
         matrix_with_explanations = M.gluing_equations_pgl(
-            N, equation_type = 'all')
+            N, equation_type='all')
 
         matrix = matrix_with_explanations.matrix
         rows = matrix_with_explanations.explain_rows
@@ -1770,7 +1769,7 @@ class CrossRatios(dict):
         SL(N,C) / {+1,-1} if N is even and is described in the Introduction of
         Garoufalidis, Thurston, Zickert
         The Complex Volume of SL(n,C)-Representations of 3-Manifolds
-        http://arxiv.org/abs/1111.2828
+        https://arxiv.org/abs/1111.2828
 
         There is a canonical group homomorphism SL(2,C)->SL(N,C) coming from
         the the natural SL(2,C)-action on the vector space Sym^{N-1}(C^2).
@@ -1782,7 +1781,7 @@ class CrossRatios(dict):
 
         num_tetrahedra = self.num_tetrahedra()
 
-        if not self.N() == 2:
+        if self.N() != 2:
             raise Exception(
                 "Cross ratios need to come from a PSL(2,C) representation")
 
@@ -1796,20 +1795,18 @@ class CrossRatios(dict):
               for v in ['z', 'zp', 'zpp']
               for t in range(num_tetrahedra)
               for index in utilities.quadruples_with_fixed_sum_iterator(N-2)])
-        
+
         return CrossRatios(d,
-                           is_numerical = self._is_numerical,
-                           manifold_thunk = self._manifold_thunk)
-                           
+                           is_numerical=self._is_numerical,
+                           manifold_thunk=self._manifold_thunk)
 
     def is_real(self, epsilon):
-
         """
         Returns True if all cross ratios are real (have absolute imaginary
         part < epsilon where epsilon is given as argument).
         This means that the corresponding representation is in PSL(N,R).
         """
-        
+
         if not self._is_numerical:
             raise NumericalMethodError("is_real")
 
@@ -1818,8 +1815,7 @@ class CrossRatios(dict):
                 return False
         return True
 
-    def is_induced_from_psl2(self, epsilon = None):
-
+    def is_induced_from_psl2(self, epsilon=None):
         """
         For each simplex and each edges, checks that all cross ratios of that
         simplex that are parallel to that each are the same (maximal absolute
@@ -1832,28 +1828,28 @@ class CrossRatios(dict):
         d = { }
 
         for key, value in self.items():
-           variable_name, index, tet_index = key.split('_')
-           if not variable_name in ['z', 'zp', 'zpp']:
-               raise Exception("Variable not z, zp, or, zpp")
-           if not len(index) == 4:
-               raise Exception("Not 4 indices")
+            variable_name, index, tet_index = key.split('_')
+            if variable_name not in ['z', 'zp', 'zpp']:
+                raise Exception("Variable not z, zp, or, zpp")
+            if len(index) != 4:
+                raise Exception("Not 4 indices")
 
-           # The key in the auxiliary dictionary
-           short_key = variable_name + '_' + tet_index
+            # The key in the auxiliary dictionary
+            short_key = variable_name + '_' + tet_index
 
-           # Get the old value in the auxiliary dictionary
-           old_value = d.setdefault(short_key, value)
+            # Get the old value in the auxiliary dictionary
+            old_value = d.setdefault(short_key, value)
 
-           if epsilon is None:
-               if not value == old_value:
-                   return False
-           else:
-               if (value - old_value).abs() > epsilon:
-                   return False
+            if epsilon is None:
+                if value != old_value:
+                    return False
+            else:
+                if (value - old_value).abs() > epsilon:
+                    return False
 
         return True
 
-    def is_pu_2_1_representation(self, epsilon, epsilon2 = None):
+    def is_pu_2_1_representation(self, epsilon, epsilon2=None):
         r"""
         Returns True if the representation is also a
         PU(2,1)-representation. This uses Proposition 3.5 and the
@@ -1916,49 +1912,56 @@ class CrossRatios(dict):
 
             return True
 
-        if not self.N() == 3:
+        if self.N() != 3:
             raise Exception("PU(2,1)-representations only allowed for N = 3")
 
         if not self._is_numerical:
             raise NumericalMethodError("is_pu_2_1_representation")
 
         for t in range(self.num_tetrahedra()):
-            
+
             m0 = mainCondition("z_1000_%d" % t, "z_0100_%d" % t,
                                "z_0010_%d" % t, "z_0001_%d" % t)
-            if not m0: return m0
+            if not m0:
+                return m0
 
             m1 = mainCondition("zp_1000_%d" % t, "zp_0010_%d" % t,
                                "zp_0100_%d" % t, "zp_0001_%d" % t)
-            if not m1: return m1
+            if not m1:
+                return m1
 
             m2 = mainCondition("zpp_1000_%d" % t, "zpp_0001_%d" % t,
                                "zpp_0100_%d" % t, "zpp_0010_%d" % t)
-            if not m2: return m2
+            if not m2:
+                return m2
 
             t0 = tripleRatioCondition(  "z_0100_%d" % t,
                                        "zp_0010_%d" % t,
                                       "zpp_0001_%d" % t)
-            if not t0: return t0
+            if not t0:
+                return t0
 
             t1 = tripleRatioCondition(  "z_1000_%d" % t,
                                        "zp_0001_%d" % t,
                                       "zpp_0010_%d" % t)
-            if not t1: return t1
+            if not t1:
+                return t1
 
             t2 = tripleRatioCondition(  "z_0001_%d" % t,
                                        "zp_1000_%d" % t,
                                       "zpp_0100_%d" % t)
-            if not t2: return t2
+            if not t2:
+                return t2
 
             t3 = tripleRatioCondition(  "z_0010_%d" % t,
                                        "zp_0100_%d" % t,
                                       "zpp_1000_%d" % t)
-            if not t3: return t3
+            if not t3:
+                return t3
 
         return True
-           
-    def is_geometric(self, epsilon = 1e-6):
+
+    def is_geometric(self, epsilon=1e-6):
         """
         Returns true if all shapes corresponding to this solution have positive
         imaginary part.
@@ -1981,10 +1984,11 @@ class CrossRatios(dict):
                     return True
             return False
 
+
 def _ptolemy_to_cross_ratio(solution_dict,
-                            branch_factor = 1,
-                            non_trivial_generalized_obstruction_class = False,
-                            as_flattenings = False):
+                            branch_factor=1,
+                            non_trivial_generalized_obstruction_class=False,
+                            as_flattenings=False):
 
     N, has_obstruction = _N_and_has_obstruction_for_ptolemys(solution_dict)
     num_tets = _num_tetrahedra(solution_dict)
@@ -2017,17 +2021,17 @@ def _ptolemy_to_cross_ratio(solution_dict,
         c1100 = get_ptolemy_coordinate((1,1,0,0))
         c0011 = get_ptolemy_coordinate((0,0,1,1))
 
-        z   =   (c1010 * c0101) / (c1001 * c0110)
-        zp  = - (c1001 * c0110) / (c1100 * c0011)
-        zpp =   (c1100 * c0011) / (c1010 * c0101)
+        z = (c1010 * c0101) / (c1001 * c0110)
+        zp = - (c1001 * c0110) / (c1100 * c0011)
+        zpp = (c1100 * c0011) / (c1010 * c0101)
 
         if has_obstruction:
             s0 = get_obstruction_variable(0)
             s1 = get_obstruction_variable(1)
             s2 = get_obstruction_variable(2)
             s3 = get_obstruction_variable(3)
-            z   = s0 * s1 * z
-            zp  = s0 * s2 * zp
+            z = s0 * s1 * z
+            zp = s0 * s2 * zp
             zpp = s0 * s3 * zpp
 
         variable_end = '_%d%d%d%d' % tuple(index) + '_%d' % tet
@@ -2043,50 +2047,53 @@ def _ptolemy_to_cross_ratio(solution_dict,
                                     branch_factor, evenN)
             wpp = _compute_flattening(c1100, c0011, c1010, c0101,
                                     branch_factor, evenN)
-            
+
             return [
-                ('z'   + variable_end, make_triple(w  ,z  )),
-                ('zp'  + variable_end, make_triple(wp ,zp )),
+                ('z' + variable_end, make_triple(w  ,z  )),
+                ('zp' + variable_end, make_triple(wp ,zp )),
                 ('zpp' + variable_end, make_triple(wpp,zpp)) ]
 
         else:
             return [
-                ('z'   + variable_end, z),
-                ('zp'  + variable_end, zp),
+                ('z' + variable_end, z),
+                ('zp' + variable_end, zp),
                 ('zpp' + variable_end, zpp) ]
-                
+
     return dict(
-        sum([compute_cross_ratios_and_flattenings(tet,index) 
-             for tet in range(num_tets) 
+        sum([compute_cross_ratios_and_flattenings(tet,index)
+             for tet in range(num_tets)
              for index in utilities.quadruples_with_fixed_sum_iterator(N - 2)],
             [])), evenN
 
+
 def _num_tetrahedra(solution_dict):
     return max( [ int(key.split('_')[-1])
                   for key in solution_dict.keys() ] ) + 1
 
+
 def _N_for_shapes(solution_dict):
-    
+
     def get_N(key):
         m = re.match(r'zp{0,2}_(\d{4})_\d+$', key)
         if not m:
             raise Exception("Not a valid shape key: '%s'" % key)
         return sum([int(char) for char in m.group(1)]) + 2
-    
+
     l = [ get_N(key) for key in solution_dict.keys() ]
     if not len(set(l)) == 1:
         raise Exception("Shape keys for different N")
-    
+
     return l[0]
 
+
 def _N_and_has_obstruction_for_ptolemys(solution_dict):
-    
+
     def get_N(key):
         m = re.match(r'c_(\d{4})_\d+$', key)
         if not m:
             raise Exception("Not a valid Ptolemy key: '%s'" % key)
         return sum([int(char) for char in m.group(1)])
-    
+
     has_obstruction = False
 
     l = set()
@@ -2102,9 +2109,10 @@ def _N_and_has_obstruction_for_ptolemys(solution_dict):
     for N in l:
         return N, has_obstruction
 
+
 def _get_number_field(d):
     for value in d.values():
-        
+
         if isinstance(value, RUR):
             nf = value.number_field()
             if nf:
@@ -2115,6 +2123,7 @@ def _get_number_field(d):
 
     return None
 
+
 def _evaluate_at_root(p, root):
 
     if type(p) == Gen and p.type() == 't_POLMOD':
@@ -2124,7 +2133,8 @@ def _evaluate_at_root(p, root):
         return p.evaluate_at_root(root)
 
     return p
-            
+
+
 def _to_numerical(d):
 
     number_field = _get_number_field(d)
@@ -2139,16 +2149,16 @@ def _to_numerical(d):
     def evaluate_all_for_root(root):
 
         def evaluate_key_for_root(key, value):
-    
+
             v = _evaluate_at_root(value, root)
-        
+
             if key[:2] == 'z_':
-                z   = v
-                zp  = 1 / (1 - z)
+                z = v
+                zp = 1 / (1 - z)
                 zpp = 1 - 1 / z
 
-                return [(key,              z),
-                        ('zp_'  + key[2:], zp),
+                return [(key, z),
+                        ('zp_' + key[2:], zp),
                         ('zpp_' + key[2:], zpp)]
             elif key[:3] == 'zp_' or key[:4] == 'zpp_':
                 return []
@@ -2161,24 +2171,26 @@ def _to_numerical(d):
 
     return [ evaluate_all_for_root(root) for root in roots ]
 
+
 def _apply_to_RURs(d, RUR_method):
-    
+
     def _apply_to_RUR(v):
         if isinstance(v, RUR):
             return RUR_method(v)
         return v
-    
-    return dict( [ (k, _apply_to_RUR(v)) for  k, v in d.items() ] )
+
+    return {k: _apply_to_RUR(v) for k, v in d.items()}
 
 
 def _convert_to_pari_float(z):
 
     if type(z) == Gen and z.type() in ['t_INT', 't_FRAC']:
         return z * pari('1.0')
-    
+
     return pari(z)
- 
-def _compute_flattening(a, b, c, d, branch_factor, N = 2):
+
+
+def _compute_flattening(a, b, c, d, branch_factor, N=2):
 
     PiMinusEpsilon = pari(3.141592)
 
@@ -2202,10 +2214,12 @@ def _compute_flattening(a, b, c, d, branch_factor, N = 2):
 
 # bug in pari
 
+
 def _dilog(z):
     return pari("dilog(%s)" % z)
 
-def _L_function(zpq_triple, evenN = 2):
+
+def _L_function(zpq_triple, evenN=2):
 
     z, p, q = zpq_triple
 
@@ -2220,12 +2234,14 @@ def _L_function(zpq_triple, evenN = 2):
             + (z.log() + p * f) * ((1-z).log() + q * f) / 2
             - Pi2 / 6)
 
+
 def _volume(z):
-    
+
     z = _convert_to_pari_float(z)
-    
+
     return (1-z).arg() * z.abs().log() + _dilog(z).imag()
 
+
 def _kronecker_delta(i, j):
     """
     Kronecker Delta, returns 1 if and only if i and j are equal, other 0.
@@ -2236,35 +2252,36 @@ def _kronecker_delta(i, j):
     else:
         return 0
 
-def _X(N, k, v):
 
+def _X(N, k, v):
     """
     Returns the NxN matrix with off-diagonal entry v at position k, that
     is the entry at row k and column k+1 is v.
 
     See (10.2) of
     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
     """
 
     m = [[_kronecker_delta(i,j) for i in range(N)] for j in range(N)]
     m[k-1][k] = v
     return m
 
+
 def _H(N, k, x):
     """
     Returns the NxN diagonal matrix where the first k diagonal entries are x
     and all other entries are 1.
-    
+
     See (10.1) of
     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
     """
 
     def _entry(i, j):
-        if not i == j:
+        if i != j:
             return 0
         if i < k:
             return x