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

snappy/verify/maximal_cusp_area_matrix/cusp_tiling_engine.py

@@ -1,21 +1,21 @@
 from ...sage_helper import _within_sage
+from ...math_basics import correct_max
 
+from ...geometric_structure.cusp_neighborhood.complex_cusp_cross_section import ComplexCuspCrossSection
 from ...snap.kernel_structures import *
 from ...snap.fundamental_polyhedron import *
 from ...snap.mcomplex_base import *
 from ...snap.t3mlite import simplex
 from ...snap import t3mlite as t3m
+from ...exceptions import InsufficientPrecisionError
 
-from ..cuspCrossSection import ComplexCuspCrossSection
-from ..mathHelpers import interval_aware_max
 from ..upper_halfspace.ideal_point import *
 from ..interval_tree import *
 
 from .cusp_translate_engine import *
 
 if _within_sage:
-    from sage.all import matrix
-    import sage.all
+    from ...sage_helper import matrix
 
 import heapq
 
@@ -28,6 +28,7 @@ _OrientedVerticesForVertex = {
     simplex.V3 : (simplex.V3, simplex.V2, simplex.V1, simplex.V0)
 }
 
+
 class CuspTilingEngine(McomplexEngine):
     """
     Test::
@@ -42,7 +43,7 @@ class CuspTilingEngine(McomplexEngine):
         [7.0000000000?, 28.00000000?, 7.0000000000?]
     """
 
-    class Tile(object):
+    class Tile():
         def __init__(self, matrix, center):
             self.matrix = matrix
             self.center = center
@@ -60,7 +61,7 @@ class CuspTilingEngine(McomplexEngine):
             idealPoints = [ self._ideal_point(corner.Tetrahedron, v)
                             for v in vertices ]
             return Euclidean_height_of_hyperbolic_triangle(idealPoints)
-        
+
         def _horo_intersection_data(self, vertex, is_at_infinity):
             corner = vertex.Corners[0]
             v0 = corner.Subsimplex
@@ -83,7 +84,10 @@ class CuspTilingEngine(McomplexEngine):
         def height_of_horosphere(self, vertex, is_at_infinity):
 
             if is_at_infinity ^ (vertex in self.vertices_at_infinity):
-                raise Exception("Error")
+                raise Exception("An inconsistency was encountered showing "
+                                "that there is a bug in the code. Please "
+                                "report the example leading to this "
+                                "exception.")
 
             pts, cusp_length = self._horo_intersection_data(vertex, is_at_infinity)
 
@@ -99,10 +103,8 @@ class CuspTilingEngine(McomplexEngine):
                 base_length = abs(invDiff(pts[2], pts[0]) - invDiff(pts[1], pts[0]))
                 return cusp_length / base_length
 
-    class UngluedGenerator(object):
+    class UngluedGenerator():
         def __init__(self, tile, g, height_upper_bound):
-            if height_upper_bound.is_NaN():
-                raise Exception("Something is wrong", height_upper_bound)
             self.tile = tile
             self.g = g
             self.height_upper_bound = height_upper_bound
@@ -116,17 +118,17 @@ class CuspTilingEngine(McomplexEngine):
     @staticmethod
     def from_manifold_and_shapes(snappyManifold, shapes):
         c = ComplexCuspCrossSection.fromManifoldAndShapes(snappyManifold, shapes)
-        c.ensure_std_form(allow_scaling_up = True)
+        c.ensure_std_form(allow_scaling_up=True)
         c.compute_translations()
         m = c.mcomplex
 
         cusp_areas = c.cusp_areas()
         translations = [ vertex.Translations for vertex in m.Vertices ]
-        
+
         t = TransferKernelStructuresEngine(m, snappyManifold)
         t.choose_and_transfer_generators(
-            compute_corners = True, centroid_at_origin = False)
-        
+            compute_corners=True, centroid_at_origin=False)
+
         f = FundamentalPolyhedronEngine(m)
         f.unglue()
 
@@ -134,12 +136,12 @@ class CuspTilingEngine(McomplexEngine):
         t = TransferKernelStructuresEngine(original_mcomplex, snappyManifold)
         t.reindex_cusps_and_transfer_peripheral_curves()
         t.choose_and_transfer_generators(
-            compute_corners = False, centroid_at_origin = False)
+            compute_corners=False, centroid_at_origin=False)
 
         return CuspTilingEngine(m, original_mcomplex, cusp_areas, translations)
 
     def __init__(self, mcomplex, original_mcomplex, cusp_areas, translations):
-        super(CuspTilingEngine, self).__init__(mcomplex)
+        super().__init__(mcomplex)
 
         self.original_mcomplex = original_mcomplex
         self.cusp_areas = cusp_areas
@@ -158,9 +160,9 @@ class CuspTilingEngine(McomplexEngine):
 
         CIF = p2.parent()
 
-        return { v0 :   Infinity,
-                 v1 :   CIF(0),
-                 v2 :   p2,
+        return { v0 : Infinity,
+                 v1 : CIF(0),
+                 v2 : p2,
                  v3 : - p3 }
 
     def reset_cusp(self, cusp_index):
@@ -180,7 +182,7 @@ class CuspTilingEngine(McomplexEngine):
         f = FundamentalPolyhedronEngine(self.mcomplex)
         init_vertices = CuspTilingEngine.get_init_vertices(self.vertex_at_infinity)
         f.visit_tetrahedra_to_compute_vertices(tet, init_vertices)
-        f.compute_matrices(normalize_matrices = False)
+        f.compute_matrices(normalize_matrices=False)
 
         self.baseTetInRadius, self.baseTetInCenter = compute_inradius_and_incenter(
             [ tet.Class[v].IdealPoint for v in simplex.ZeroSubsimplices])
@@ -198,7 +200,7 @@ class CuspTilingEngine(McomplexEngine):
         translated_center1 = e.translate_to_match(center1, center2)
         if not translated_center1:
             return False
-        
+
         dist = translated_center1.dist(center2)
 
         if dist < self.baseTetInRadius:
@@ -206,10 +208,11 @@ class CuspTilingEngine(McomplexEngine):
         if dist > self.baseTetInRadius:
             return False
 
-        raise Exception(
-            "Distance between two given centers of tiles cannot be verified "
-            "to be small enough to be the same or large enough to be two different "
-            "tiles")
+        raise InsufficientPrecisionError(
+            "When tiling, it could not be decided whether two given tiles are "
+            "the same since the distance between their respective center "
+            "cannot be verified to be either small or large enough. This can "
+            "be avoided by increasing the precision.")
 
     def find_tile(self, m):
         center = self.baseTetInCenter.translate_PGL(m)
@@ -229,16 +232,16 @@ class CuspTilingEngine(McomplexEngine):
             self.intervalTree.insert(key, tile)
 
         return tile
-        
+
     def unglued_generators_and_vertices_for_tile(self, tile):
         unglued_generators = []
         unglued_vertices = set(self.mcomplex.Vertices)
-        
+
         for g, gen_m in sorted(self.mcomplex.GeneratorMatrices.items()):
             other_m = tile.matrix * gen_m
             other_tile = self.find_tile(other_m)
             if other_tile:
-                if not tile is other_tile:
+                if tile is not other_tile:
                     for (corner, other_corner), perm in self.mcomplex.Generators[g]:
                         for v in simplex.VerticesOfFaceCounterclockwise[corner.Subsimplex]:
                             vertex = corner.Tetrahedron.Class[v]
@@ -273,13 +276,13 @@ class CuspTilingEngine(McomplexEngine):
         m = matrix.identity(CIF, 2)
 
         corner = self.vertex_at_infinity.Corners[0]
-        
+
         return (corner.Tetrahedron.Index, corner.Subsimplex, m)
 
     def get_neighboring_cusp_triangles(self, cusp_triangle):
         tet_index, V, m = cusp_triangle
         tet = self.original_mcomplex.Tetrahedra[tet_index]
-        
+
         for F in simplex.TwoSubsimplices:
             if simplex.is_subset(V, F):
                 yield( (tet.Neighbor[F].Index,
@@ -298,10 +301,10 @@ class CuspTilingEngine(McomplexEngine):
             cusp_triangle = pending_cusp_triangles.pop()
             tet_index, V, m = cusp_triangle
             key = (tet_index, V)
-            if not key in processed_cusp_triangles:
+            if key not in processed_cusp_triangles:
                 processed_cusp_triangles.add(key)
                 tet = self.mcomplex.Tetrahedra[tet_index]
-                
+
                 tile = self.find_tile(m)
                 if not tile:
                     tile = self.create_tile(m)
@@ -313,7 +316,7 @@ class CuspTilingEngine(McomplexEngine):
 
                 if self.horosphere_at_inf_height is None:
                     self.horosphere_at_inf_height = (
-                        tile.height_of_horosphere(vertex, is_at_infinity = True))
+                        tile.height_of_horosphere(vertex, is_at_infinity=True))
 
                 for neighboring_triangle in self.get_neighboring_cusp_triangles(cusp_triangle):
                     pending_cusp_triangles.append(neighboring_triangle)
@@ -321,7 +324,7 @@ class CuspTilingEngine(McomplexEngine):
         for tile, pending_vertices in unprocessed_vertices:
             for vertex in pending_vertices:
                 # Compute horosphere heights
-                if not vertex in tile.vertices_at_infinity:
+                if vertex not in tile.vertices_at_infinity:
                     self.account_horosphere_height(
                         tile, vertex)
 
@@ -336,26 +339,33 @@ class CuspTilingEngine(McomplexEngine):
             self.process_next_unglued_generator()
 
     def upper_bound_for_height_of_unglued_generator(self, tile, g):
-        return max(
-            [ tile.height_of_face(corner).upper()
-              for (corner, other_corner), perm in self.mcomplex.Generators[g] ])
-    
+        heights = [
+            tile.height_of_face(corner).upper()
+            for (corner, other_corner), perm in self.mcomplex.Generators[g] ]
+        for height in heights:
+            if height.is_NaN():
+                raise InsufficientPrecisionError(
+                    "A NaN occurred when computing the height of a triangle "
+                    "face. This can most likely be avoided by increasing the "
+                    "precision.")
+        return max(heights)
+
     def account_horosphere_height(self, tile, vertex):
         horosphere_height = tile.height_of_horosphere(vertex,
-                                                      is_at_infinity = False)
+                                                      is_at_infinity=False)
 
         cusp = vertex.SubsimplexIndexInManifold
-        
-        self.max_horosphere_height_for_cusp[cusp] = interval_aware_max(
+
+        self.max_horosphere_height_for_cusp[cusp] = correct_max(
             [self.max_horosphere_height_for_cusp[cusp], horosphere_height])
 
     def record_unglued_generator(self, tile, g):
         heapq.heappush(
             self.unglued_generator_heapq,
             CuspTilingEngine.UngluedGenerator(
-                tile = tile,
-                g = g,
-                height_upper_bound = self.upper_bound_for_height_of_unglued_generator(tile, g)))
+                tile=tile,
+                g=g,
+                height_upper_bound=self.upper_bound_for_height_of_unglued_generator(tile, g)))
 
     def process_next_unglued_generator(self):
         unglued_generator = heapq.heappop(self.unglued_generator_heapq)
@@ -364,7 +374,7 @@ class CuspTilingEngine(McomplexEngine):
              self.mcomplex.GeneratorMatrices[unglued_generator.g])
         if not self.find_tile(m):
             tile = self.create_tile(m)
-            
+
             unglued_generators, unglued_vertices = (
                 self.unglued_generators_and_vertices_for_tile(tile))
 
@@ -391,7 +401,7 @@ class CuspTilingEngine(McomplexEngine):
                      self.max_horosphere_height_for_cusp[i])
             return self.cusp_areas[i] * cusp_area * (ratio ** 2)
 
-        return [ maximal_cusp_area(i) for i in range(self.num_cusps) ]
+        return [maximal_cusp_area(i) for i in range(self.num_cusps)]
 
     def compute_maximal_cusp_area_matrix_row(self, cusp_index):
         self.reset_cusp(cusp_index)
@@ -399,11 +409,11 @@ class CuspTilingEngine(McomplexEngine):
         self.tile_until_done()
         return self.retrieve_maximal_cusp_area_matrix_row()
 
+
 def _doctest():
     import doctest
     doctest.testmod()
 
+
 if __name__ == '__main__':
     _doctest()
-
-

snappy/verify/maximal_cusp_area_matrix/cusp_translate_engine.py

@@ -3,11 +3,12 @@ from ...sage_helper import _within_sage
 from ..upper_halfspace.finite_point import *
 
 if _within_sage:
-    from sage.all import vector, matrix
+    from ...sage_helper import vector, matrix
 
 __all__ = ['CuspTranslateEngine']
 
-class CuspTranslateEngine(object):
+
+class CuspTranslateEngine():
     def __init__(self, t0, t1):
         self.t0 = t0
         self.t1 = t1
@@ -16,17 +17,17 @@ class CuspTranslateEngine(object):
         b = t1.real()
         c = t0.imag()
         d = t1.imag()
-        
+
         det = a * d - b * c
 
         self._matrix = matrix([[ d / det, -b / det],
-                               [-c / det,  a / det]])
+                               [-c / det, a / det]])
 
     def _to_vec(self, z):
         v = self._matrix * vector([z.real(), z.imag()])
         for e in v:
             if not (e.absolute_diameter() < 0.5):
-                raise Exception("Too large interval")
+                raise RuntimeError("Too large interval encountered when tiling. Increasing the precision should fix this.")
         return v
 
     def _canonical_translates(self, z):
@@ -36,61 +37,59 @@ class CuspTranslateEngine(object):
 
         v = self._to_vec(z)
         integer_ranges = [ round_to_nearest_integers(i) for i in v ]
-        
+
         for i in integer_ranges[0]:
             for j in integer_ranges[1]:
                 yield z - i * self.t0 - j * self.t1
 
     def canonical_translates(self, finitePoint):
         """
-        Test::
-
-        sage: from sage.all import *
-        sage: t0 = CIF(RIF(2.3, 2.30000000001), 3.4)
-        sage: t1 = CIF(4.32, RIF(5.43, 5.4300000001))
-        sage: c = CuspTranslateEngine(t0, t1)
-        sage: z = CIF(0.23, 0.43)
-        sage: t = RIF(5)
-        sage: for i in range(-2, 3): # doctest: +NUMERIC6
-        ...     for j in range(-2, 3):
-        ...         print(list(c.canonical_translates(FinitePoint(z + i * t0 + j * t1, t))))
-        [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.23000000000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.230000000000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.23000000000000001? + 0.43000000000000000?*I, 5)]
-        [FinitePoint(0.230000000000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.23000000000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
-        [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
-
-        sage: list(c.canonical_translates(FinitePoint(t0 / 2, t)))
-        [FinitePoint(1.15000000000? + 1.7000000000000000?*I, 5), FinitePoint(-1.15000000000? - 1.7000000000000000?*I, 5)]
-
-        sage: list(c.canonical_translates(FinitePoint(t1 / 2, t)))
-        [FinitePoint(2.1600000000000002? + 2.7150000000?*I, 5), FinitePoint(-2.1600000000000002? - 2.7150000000?*I, 5)]
-
-        sage: list(c.canonical_translates(FinitePoint(t0 / 2 + t1 / 2, t)))
-        [FinitePoint(3.31000000001? + 4.4150000000?*I, 5), FinitePoint(-1.01000000000? - 1.015000000?*I, 5), FinitePoint(1.01000000000? + 1.0150000000?*I, 5), FinitePoint(-3.3100000000? - 4.415000000?*I, 5)]
-
+        TESTS::
+
+            sage: from sage.all import *
+            sage: t0 = CIF(RIF(2.3, 2.30000000001), 3.4)
+            sage: t1 = CIF(4.32, RIF(5.43, 5.4300000001))
+            sage: c = CuspTranslateEngine(t0, t1)
+            sage: z = CIF(0.23, 0.43)
+            sage: t = RIF(5)
+            sage: for i in range(-2, 3): # doctest: +NUMERIC6
+            ...     for j in range(-2, 3):
+            ...         print(list(c.canonical_translates(FinitePoint(z + i * t0 + j * t1, t))))
+            [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.23000000000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.230000000000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.23000000000000001? + 0.43000000000000000?*I, 5)]
+            [FinitePoint(0.230000000000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.23000000000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
+            [FinitePoint(0.2300000000? + 0.430000000?*I, 5)]
+
+            sage: list(c.canonical_translates(FinitePoint(t0 / 2, t)))
+            [FinitePoint(1.15000000000? + 1.7000000000000000?*I, 5), FinitePoint(-1.15000000000? - 1.7000000000000000?*I, 5)]
+
+            sage: list(c.canonical_translates(FinitePoint(t1 / 2, t)))
+            [FinitePoint(2.1600000000000002? + 2.7150000000?*I, 5), FinitePoint(-2.1600000000000002? - 2.7150000000?*I, 5)]
+
+            sage: list(c.canonical_translates(FinitePoint(t0 / 2 + t1 / 2, t)))
+            [FinitePoint(3.31000000001? + 4.4150000000?*I, 5), FinitePoint(-1.01000000000? - 1.015000000?*I, 5), FinitePoint(1.01000000000? + 1.0150000000?*I, 5), FinitePoint(-3.3100000000? - 4.415000000?*I, 5)]
         """
-
         for z in self._canonical_translates(finitePoint.z):
             yield FinitePoint(z, finitePoint.t)
 
@@ -143,14 +142,11 @@ class CuspTranslateEngine(object):
         FinitePoint(0.3? + 0.430000000000000?*I, 5)
         FinitePoint(0.3? + 0.430000000?*I, 5)
         FinitePoint(0.3? + 0.430000000?*I, 5)
-        
+
         sage: perturb = CIF(0.1, 0)
         sage: c.translate_to_match(FinitePoint(z + 2 * t0 + 1 * t1 + perturb, t), FinitePoint(z, t)) is None
         True
-        
-        
         """
-
         z = self._translate_to_match(finitePoint.z, targetFinitePoint.z)
         if z is None:
             return None

snappy/verify/{realAlgebra.py → real_algebra.py}

@@ -12,11 +12,13 @@ if _within_sage:
     from sage.functions.other import binomial
     from ..sage_helper import ComplexField
 
+
 class _IsolateFactorError(RuntimeError):
     """
     Exception raised by _find_unique_good_factor.
     """
 
+
 def _find_unique_good_factor(polynomial, eval_method):
     """
     Given a Sage polynomial, factor it. Return the unique factor for which the
@@ -24,19 +26,20 @@ def _find_unique_good_factor(polynomial, eval_method):
     one factor have this property, raise an exception.
     """
 
-    # Factor polynomial. Call eval_method on each factor which is suppsed to
+    # Factor polynomial. Call eval_method on each factor which is supposed to
     # return an interval. Get those factors for which the resulting interval
     # contains 0.
     good_factors = [ factor
                      for factor, multiplicity in polynomial.factor()
                      if 0 in eval_method(factor)]
-    
+
     # No unique factor, bail with an exception.
     if not len(good_factors) == 1:
         raise _IsolateFactorError()
 
     return good_factors[0]
 
+
 def _solve_two_equations(eqn1, eqn2, x_val, y_val):
     """
     Given two polynomial equations with rational coefficients in 'x' and 'y'
@@ -48,7 +51,7 @@ def _solve_two_equations(eqn1, eqn2, x_val, y_val):
 
     # Ring we work in Q[x][y]
     Rx = PolynomialRing(RationalField(), 'x')
-    R  = PolynomialRing(Rx, 'y')
+    R = PolynomialRing(Rx, 'y')
     Reqn1 = R(eqn1)
 
     # Compute the resultant in Q[x]
@@ -65,7 +68,7 @@ def _solve_two_equations(eqn1, eqn2, x_val, y_val):
     resultant_factor = _find_unique_good_factor(resultant, eval_factor_res)
 
     resultant_factor = Rx(resultant_factor)
-    
+
     # The number field generated by x.
     #
     # (The embedding passed to the NumberField is a real number, so sage
@@ -74,8 +77,8 @@ def _solve_two_equations(eqn1, eqn2, x_val, y_val):
     #    _find_unique_good_factor)
 
     result_number_field = NumberField(resultant_factor, 'x',
-                                      embedding = x_val.center())
-    
+                                      embedding=x_val.center())
+
     # Get one of the equations and think of it as an element in NumberField[y]
     yEqn = Reqn1.change_ring(result_number_field)
 
@@ -90,8 +93,8 @@ def _solve_two_equations(eqn1, eqn2, x_val, y_val):
         """
 
         lift = p.map_coefficients(lambda c:c.lift('x'), Rx)
-        return lift.substitute(x = x_val, y = y_val)
-    
+        return lift.substitute(x=x_val, y=y_val)
+
     yEqn_factor = _find_unique_good_factor(yEqn, eval_factor_yEqn)
 
     # If the equation for y in x is not of degree 1, then y is in a field
@@ -102,7 +105,7 @@ def _solve_two_equations(eqn1, eqn2, x_val, y_val):
 
     # The equation of y is of the form
     #     linear_term * y + constant_term = 0
-    constant_term, linear_term = yEqn_factor.coefficients(sparse = False)
+    constant_term, linear_term = yEqn_factor.coefficients(sparse=False)
 
     # Thus, y is given by - constant_term / linear_term
     return result_number_field, - constant_term / linear_term
@@ -127,11 +130,13 @@ def _real_or_imaginary_part_of_power_of_complex_number(n, start):
         binomial(n, i) * (-1) ** (i//2) * var('x') ** (n - i) * var('y') ** i
         for i in range(start, n + 1, 2)])
 
+
 def _real_or_imaginary_part_for_polynomial_in_complex_variable(polynomial,
                                                                start):
     """
-    Given a polynomial p with rational coefficients, return the 
+    Given a polynomial p with rational coefficients, return the
     real (start = 0) / imaginary (start = 1) part of p(x + y * I).
+
     The result is a sage symbolic expression in x and y with rational
     coefficients.
     """
@@ -140,8 +145,9 @@ def _real_or_imaginary_part_for_polynomial_in_complex_variable(polynomial,
 
     return sum([
         coeff * _real_or_imaginary_part_of_power_of_complex_number(i, start)
-        for i, coeff in enumerate(polynomial.coefficients(sparse = False))])
-    
+        for i, coeff in enumerate(polynomial.coefficients(sparse=False))])
+
+
 @sage_method
 def field_containing_real_and_imaginary_part_of_number_field(number_field):
     """
@@ -153,7 +159,7 @@ def field_containing_real_and_imaginary_part_of_number_field(number_field):
 
     real_part and imag_part are elements in real_number_field which comes with
     a real embedding such that under this embedding, we have
-               z = real_part + imag_part * I.
+    ``z = real_part + imag_part * I``.  ::
 
         sage: CF = ComplexField()
         sage: x = var('x')
@@ -174,10 +180,10 @@ def field_containing_real_and_imaginary_part_of_number_field(number_field):
     # Given the one complex equation p(z) = 0, translate it into two
     # real equations Re(p(x+y*I)) = 0, Im(p(x+y*I)) = 0.
     # equations are sage symbolic expressions in x and y.
-    equations = [ 
-      _real_or_imaginary_part_for_polynomial_in_complex_variable(
-          number_field.defining_polynomial(), start)
-      for start in [0, 1]]
+    equations = [
+        _real_or_imaginary_part_for_polynomial_in_complex_variable(
+            number_field.defining_polynomial(), start)
+        for start in [0, 1]]
 
     # In _solve_two_equations, we implemented a method that can solve
     # a system of two polynomial equations in two variables x and y
@@ -211,7 +217,7 @@ def field_containing_real_and_imaginary_part_of_number_field(number_field):
 
         # From the equations for x and y, get the equations for x' and y
         # where x' = x + k * y as abover
-        equations_for_xprime = [ eqn.substitute(x = var('x') - k * var('y'))
+        equations_for_xprime = [ eqn.substitute(x=var('x') - k * var('y'))
                                  for eqn in equations ]
 
         try:
@@ -250,7 +256,8 @@ def field_containing_real_and_imaginary_part_of_number_field(number_field):
     # Give up
     return None
 
-def _test_result(number_field, prec = 53, epsilon = 1e-10):
+
+def _test_result(number_field, prec=53, epsilon=1e-10):
     """
         sage: CF = ComplexField()
         sage: x = var('x')
@@ -262,7 +269,6 @@ def _test_result(number_field, prec = 53, epsilon = 1e-10):
         sage: _test_result(nf, 212, epsilon = 1e-30)
     """
 
-
     CIF = ComplexIntervalField(prec)
     RIF = RealIntervalField(prec)
     epsilon = RIF(epsilon)

snappy/verify/shapes.py

@@ -1,16 +1,19 @@
-from . import verifyHyperbolicity
+from . import hyperbolicity
 
 __all__ = ['compute_hyperbolic_shapes']
 
-def compute_hyperbolic_shapes(manifold, verified, bits_prec = None):
+from typing import Optional
+
+def compute_hyperbolic_shapes(manifold,
+                              verified : bool, bits_prec : Optional[int] = None):
 
     # Get shapes, as intervals if requested
-    shapes = manifold.tetrahedra_shapes('rect', intervals = verified,
-                                        bits_prec = bits_prec)
-    
+    shapes = manifold.tetrahedra_shapes('rect', intervals=verified,
+                                        bits_prec=bits_prec)
+
     # Check it is a valid hyperbolic structure
     if verified:
-        verifyHyperbolicity.check_logarithmic_gluing_equations_and_positively_oriented_tets(
+        hyperbolicity.check_logarithmic_gluing_equations_and_positively_oriented_tets(
             manifold, shapes)
     else:
         # If not verified, just ask SnapPea kernel for solution type
@@ -18,5 +21,5 @@ def compute_hyperbolic_shapes(manifold, verified, bits_prec = None):
         if not sol_type == 'all tetrahedra positively oriented':
             raise RuntimeError(
                 "Manifold has non-geometric solution type '%s'." % sol_type)
-        
+
     return shapes