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

snappy/canonical.py

@@ -0,0 +1,249 @@
+from . import verify
+from . import Triangulation, TriangulationHP, Manifold, ManifoldHP
+
+from typing import Optional, Union, Sequence, Tuple
+
+__all__ = ['canonical_retriangulation', 'canonical_retriangulation_hp']
+
+def _canonical_retriangulation(
+        manifold : Union[Manifold, ManifoldHP],
+        verified : bool,
+        interval_bits_precs : Sequence[int],
+        exact_bits_prec_and_degrees : Sequence[Tuple[int, int]],
+        verbose : bool) -> Union[Triangulation, TriangulationHP,
+                                 Manifold, ManifoldHP]:
+    """
+    Returns a triangulation canonically associated to the hyperbolic manifold.
+    That is, the triangulation is (up to combinatorial isomorphism relabeling
+    the tetrahedra and vertices) completely determined by the isometry type of
+    the hyperbolic manifold.
+
+    Manifolds with incomplete cusps are rejected (unlike in the case of
+    :meth:`isometry_signature <snappy.Manifold.isometry_signature>`).
+
+    We now describe the canonical retriangulation. If all cells of
+    the canonical cell decomposition (defined by `Epstein and Penner '88
+    <https://projecteuclid.org/euclid.jdg/1214441650>`_) are tetrahedral,
+    :meth:`canonical_retriangulation <Manifold.canonical_retriangulation>`
+    simply returns that ideal triangulation as a
+    :class:`Manifold <snappy.Manifold>`. Here is an example::
+
+       >>> M = Manifold("m015")
+       >>> K = M.canonical_retriangulation()
+       >>> K.has_finite_vertices()
+       False
+       >>> K.solution_type()
+       'all tetrahedra positively oriented'
+
+    If there are non-tetrahedral cells,
+    :meth:`canonical_retriangulation <Manifold.canonical_retriangulation>`
+    subdivides the canonical cell decomposition. It introduces a finite vertex
+    for each canonical cell resulting in a
+    :class:`Triangulation <snappy.Triangulation>`. Here is an example where the
+    canonical cell is a cube::
+
+       >>> M = Manifold("m412")
+       >>> K = M.canonical_retriangulation()
+       >>> K.has_finite_vertices()
+       True
+
+    The canonical retriangulation can be used to find the symmetries of a
+    single manifold. It also can compute the isometries between two
+    manifolds. We do this using
+    :meth:`isomorphisms_to <snappy.Triangulation.isomorphisms_to>`::
+
+       >>> M = Manifold("5_2").canonical_retriangulation()
+       >>> N = Manifold("m015").canonical_retriangulation()
+       >>> M.isomorphisms_to(M) #doctest: +ELLIPSIS
+       [0 -> 0
+       [1 0]
+       [0 1]
+       ...
+       >>> M.isomorphisms_to(N) #doctest: +ELLIPSIS
+       [0 -> 0
+       [-1  2]
+       [ 0 -1]
+       ...
+
+    The canonical retriangulation is also the basis for the
+    :meth:`isometry_signature <snappy.Manifold.isometry_signature>`.
+
+    **Subdivision**
+
+    If the canonical cell decomposition has a non-tetrahedral cell, the method
+    subdivides. You can think of the subdivision in either of the following
+    (equivalent) ways:
+
+    - A coarsening of the barycentric subdivision with only a quarter of the
+      number of tetrahedra. That is, take the barycentric subdivision and
+      merge the four tetrahedra adjacent to a barycentric edge connecting
+      an edge midpoint to a face midpoint.
+    - Taking the double suspension of each face (which is an ideal n-gon)
+      about the centers of the two neighboring 3-cells. Then split each
+      such topological "lens" into n tetrahedra along its central axis.
+
+    **Verified computations**
+
+    While the canonical retriangulation is combinatorial, some intermediate
+    computations are numerical. Thus, if :attr:`verified = False`,
+    floating-point issues can arise.
+    (Arguably this gave rise to a mistake in the
+    non-orientable census. ``x101`` and ``x103`` were later identified as
+    the same by `Burton '14 <http://arxiv.org/abs/1311.7615>`_.)
+
+    The method can be made :ref:`verified <verify-primer>` by passing
+    :attr:`verified = True`::
+
+      sage: M = Manifold("v2986")
+      sage: K = M.canonical_retriangulation(verified = True)
+      sage: K.has_finite_vertices() # Cell decomposition verified to be tetrahedral
+      False
+      sage: K.triangulation_isosig(decorated=False) # Verified isometry signature.
+      'jvLALQQdeefgihihiokcmmwwswg'
+      sage: len(K.isomorphisms_to(K)) # Verified to have no (non-trivial) symmetries.
+      1
+
+    Interval arithmetic can only be used to verify the canonical cell decomposition
+    if all cells are tetrahedral. For non-tetrahedral cells, the method
+    automatically switches to
+    exact methods to verify the canonical cell decomposition. That is, it uses
+    snap-like methods
+    (`LLL-algorithm <http://en.wikipedia.org/wiki/Lenstra%E2%80%93Lenstra%E2%80%93Lov%C3%A1sz_lattice_basis_reduction_algorithm>`_)
+    to guess a representation of the
+    shapes in the shape field. It then uses exact arithmetic to verify the
+    shapes form a valid geometric structure and compute the necessary tilts
+    to verify the canonical cell decomposition. Note that this can take a
+    long time!
+
+    Here is an example where exact methods are used::
+
+      sage: M = Manifold("m412")
+      sage: K = M.canonical_retriangulation(verified = True)
+      sage: K.has_finite_vertices() # Has non-tetrahedral cell
+      True
+
+    If the canonical retriangulation cannot be verified, an exception will be
+    raised. (Note that this is new (and safer) in Version 3.2. Prior to that
+    version, :meth:`Manifold.canonical_retriangulation` could return ``None``
+    instead.)
+
+    Here is an example where we skip the (potentially lengthy) exact methods
+    needed to verify a non-tetrahedral cell. The method fails (early
+    and with an exception) since the cells are actually tetrahedral::
+
+      sage: M = Manifold("m412")
+      sage: K = M.canonical_retriangulation(verified = True, exact_bits_prec_and_degrees = []) # doctest: +ELLIPSIS +IGNORE_EXCEPTION_DETAIL
+      Traceback (most recent call last):
+      ...
+      snappy.verify.exceptions.TiltInequalityNumericalVerifyError: Numerical verification that tilt is negative has failed: ... < 0
+
+    :param verified:
+            Use :ref:`verified computation <verify-primer>`.
+    :param interval_bits_precs:
+            Only relevant if :attr:`verified = True`.
+            A list of (increasing) precisions used to try to
+            certify the canonical cell decomposition using intervals. Each
+            precision is tried until we succeed. If none succeeded, we move on
+            to exact methods.
+    :param exact_bits_prec_and_degrees:
+            Only relevant if :attr:`verified = True`.
+            A list of pairs (precision, max degree) used when the
+            LLL-algorithm is trying to find the defining
+            polynomial of the shape field with
+            ``ListOfApproximateAlgebraicNumbers.find_field``.
+            Each pair is tried until we succeed.
+    :param verbose:
+            Print information about the methods tried to compute and verify the
+            canonical retriangulation.
+    :return:
+            If the canonical cell decomposition exists entirely of
+            (hyperbolic ideal) tetrahedra, a :class:`Manifold` with those
+            tetrahedra.
+            Otherwise, a :class:`Triangulation` that is a subdivision of the
+            canonical cell decomposition.
+    """
+
+    # More information on the canonical retriangulation can be found in the
+    # SnapPea kernel ``canonize_part_2.c`` and in Section 3.1 of
+    # `Fominykh, Garoufalidis, Goerner, Tarkaev, Vesnin <http://arxiv.org/abs/1502.00383>`_.
+
+    if not all(manifold.cusp_info('complete?')):
+        # It is unclear what to do when there are filling coefficients.
+        # The SnapPea kernel ignores them and uses the complete structure
+        # to compute the canonical retriangulation.
+        #
+        # That makes sense to, e.g., compute a canonical representation
+        # of a surgery diagram.
+        #
+        # In other situations, it makes perfectly sense to fill the cusps
+        # instead. That is, e.g., what the isometry_signature does.
+        #
+        # Since it is ambiguous, I decided to simply reject it here.
+        #
+        # It is easy enough for a user to either call fill_triangulation
+        # or to save the coefficients and unfill all cusps.
+        #
+        raise ValueError(
+            'Canonical retriangulation needs all cusps to be complete.')
+
+    if verified:
+        # verified_canonical_retriangulation has code to check
+        # for incomplete cusps and fill them that never gets
+        # executed because of the above "if"
+        return verify.verified_canonical_retriangulation(
+            manifold,
+            interval_bits_precs=interval_bits_precs,
+            exact_bits_prec_and_degrees=exact_bits_prec_and_degrees,
+            verbose=verbose)
+    else:
+        # Note that the SnapPea kernel actually ignores Dehn-fillings
+        # when computing the canonical retriangulation.
+        if not all(manifold.cusp_info('complete?')):
+            # Never executed because of above "if".
+            manifold = manifold.filled_triangulation()
+            if not all(manifold.cusp_info('complete?')):
+                raise ValueError(
+                    'Could not compute filled triangulation. '
+                    'Are the filling coefficients co-prime integers?')
+
+        K = manifold._canonical_retriangulation()
+        if K.has_finite_vertices():
+            return K
+        else:
+            if isinstance(manifold, ManifoldHP):
+                return ManifoldHP(K)
+            else:
+                return Manifold(K)
+
+# Wraps _canonical_retriangulation to have the correct return type
+def canonical_retriangulation(
+        manifold : Manifold,
+        verified : bool = False,
+        interval_bits_precs : Sequence[int] = verify.default_interval_bits_precs,
+        exact_bits_prec_and_degrees : Sequence[Tuple[int, int]] = verify.default_exact_bits_prec_and_degrees,
+        verbose : bool = False) -> Union[Triangulation, Manifold]:
+    return _canonical_retriangulation(
+        manifold,
+        verified = verified,
+        interval_bits_precs = interval_bits_precs,
+        exact_bits_prec_and_degrees = exact_bits_prec_and_degrees,
+        verbose = verbose)
+canonical_retriangulation.__doc__ = _canonical_retriangulation.__doc__
+            
+# Wraps _canonical_retriangulation to have the correct return type
+def canonical_retriangulation_hp(
+        manifold : ManifoldHP,
+        verified : bool = False,
+        interval_bits_precs : Sequence[int] = verify.default_interval_bits_precs,
+        exact_bits_prec_and_degrees : Sequence[Tuple[int, int]] = verify.default_exact_bits_prec_and_degrees,
+        verbose : bool = False) -> Union[TriangulationHP, ManifoldHP]:
+    return _canonical_retriangulation(
+        manifold,
+        verified = verified,
+        interval_bits_precs = interval_bits_precs,
+        exact_bits_prec_and_degrees = exact_bits_prec_and_degrees,
+        verbose = verbose)
+canonical_retriangulation_hp.__doc__ = _canonical_retriangulation.__doc__
+
+
+

snappy/{verify/cusp_shapes.py → cusps/__init__.py}

@@ -1,23 +1,15 @@
-from .cuspCrossSection import ComplexCuspCrossSection
-from .shapes import compute_hyperbolic_shapes
+"""
+Computing data about cusps such as cusp matrix, shape, translations
+and exceptional slopes.
+"""
 
-__all__ = ['NonorientableManifoldError', 'compute_cusp_shapes']
+from ..geometric_structure.cusp_neighborhood.complex_cusp_cross_section import ComplexCuspCrossSection
+from ..verify.shapes import compute_hyperbolic_shapes
+from ..exceptions import NonorientableManifoldError
 
-class NonorientableManifoldError(RuntimeError):
+def compute_cusp_shapes(manifold, verified, bits_prec=None):
     """
-    Exception raised when trying to compute cusp shapes for a non-orientable
-    manifold.
-    """
-    def __init__(self, manifold):
-        self.manifold = manifold
-
-    def __str__(self):
-        return (('Cannot compute cusp shapes for non-orientable '
-                 'manifold %s') % self.manifold)
-
-def compute_cusp_shapes(manifold, verified, bits_prec = None):
-    """
-    Compute verified cusp shapes (following the SnapPea kernel convention,
+    Compute cusp shapes. Following the SnapPea kernel convention,
     it returns the conjugate of the quotient of the translations
     corresponding to the longitude and meridian for each cusp.
 
@@ -28,7 +20,7 @@ def compute_cusp_shapes(manifold, verified, bits_prec = None):
     sage: M = Manifold('s843')
     sage: M.cusp_info('shape', verified = True) # doctest: +NUMERIC12
     [0.46738227587? + 1.19036005068?*I, 0.0841873244146? + 1.0506945576790?*I]
-    
+
     sage: M.cusp_info('shape', verified = True, bits_prec = 100) # doctest: +NUMERIC21
     [0.4673822758634149679181698? + 1.1903600506742881207098974?*I, 0.084187324414612694374797272? + 1.050694557679002004845675723?*I]
     """
@@ -37,7 +29,7 @@ def compute_cusp_shapes(manifold, verified, bits_prec = None):
         raise NonorientableManifoldError(manifold)
 
     shapes = compute_hyperbolic_shapes(
-        manifold, verified = verified, bits_prec = bits_prec)
+        manifold, verified=verified, bits_prec=bits_prec)
 
     # Compute cusp cross section
     c = ComplexCuspCrossSection.fromManifoldAndShapes(manifold, shapes)

snappy/cusps/cusp_area_matrix.py

@@ -0,0 +1,101 @@
+from .maximal_cusp_area_matrix import maximal_cusp_area_matrix
+from .trig_cusp_area_matrix import triangulation_dependent_cusp_area_matrix
+from ..verify.maximal_cusp_area_matrix import legacy_verified_maximal_cusp_area_matrix
+
+from typing import Optional
+
+def cusp_area_matrix(
+        manifold,
+        method : str = 'maximal',
+        verified : bool = False,
+        bits_prec : Optional[int] = None):
+    """
+    Returns the maximal cusp area matrix :math:`(A_{ij})` where
+    :math:`A_{ij}` is defined as follows.
+    Let :math:`C_i` and :math:`C_j` be the (open) cusp neighborhoods about cusp
+    :math:`i` and :math:`j`. Let :math:`A(C_i)` and :math:`A(C_j)` be the
+    areas of :math:`C_i` and :math:`C_j`, respectively. Then, :math:`C_i`
+    and :math:`C_j` are embedded (if :math:`i = j`) or disjoint (otherwise)
+    if and only if :math:`A(C_i)A(C_j) \\leq A_{ij}`.
+
+    Here is an example::
+    
+        >>> M = Manifold("L6a5")
+        >>> M.cusp_area_matrix() # doctest: +NUMERIC12
+        [27.9999999999996 7.00000000000000 7.00000000000000]
+        [7.00000000000000 27.9999999999999 7.00000000000000]
+        [7.00000000000000 7.00000000000000 28.0000000000001]
+
+
+    **Faster lower bounds**
+
+    This section can be skipped by most users!
+
+    Prior to SnapPy version 3.2, the algorithm to compute the maximal cusp
+    area matrix was much slower and required :attr:`verified = True` and
+    SageMath. Thus, in prior versions, :attr:`method` defaulted to
+    ``trigDependentTryCanonize``. This meant, that, by default,
+    :meth:`~snappy.Manifold.cusp_area_matrix` only returned
+    (some) lower bounds for the maximal cusp area matrix entries.
+
+    These lower bounds can still be accessed::
+
+        >>> M.cusp_area_matrix(method = 'trigDependentTryCanonize') # doctest: +NUMERIC12
+        [21.4375000000000 7.00000000000000 7.00000000000000]
+        [7.00000000000000 28.0000000000000 7.00000000000000]
+        [7.00000000000000 7.00000000000000 28.0000000000000]
+
+    If :attr:`method = 'trigDependent'` or
+    :attr:`method = 'trigDependenyTryCanonize'`, the result is triangulation
+    dependent or not even deterministic, respectively.
+    Furthermore, if :attr:`verified = True` is also set, while the left
+    endpoints of the intervals are lower bounds for the maximal cusp area
+    matrix entries, the right endpoints are meaningless and could be smaller
+    or larger than the maximal cusp area matrix entries.
+
+    **Verified computation**
+
+    If :attr:`verified = False`, floating-point issues can arise resulting in
+    incorrect values. The method can be made
+    :ref:`verified <verify-primer>` by passing :attr:`verified = True`::
+
+        sage: M.cusp_area_matrix(verified=True) # doctest: +NUMERIC3
+        [       28.0000? 7.000000000000?  7.00000000000?]
+        [7.000000000000?      28.000000?  7.00000000000?]
+        [ 7.00000000000?  7.00000000000?       28.00000?]
+
+    :param verified:
+            Use :ref:`verified computation <verify-primer>`.
+    :param bits_prec:
+            Precision used for computation. Increase if computation
+            did not succeed or a more precise result is desired.
+    :param method:
+            Switches to older algorithms giving lower bounds when
+            ``trigDependentTryCanonize`` and ``trigDependent``.
+    :return:
+            Maximal cusp area matrix (default) or lower bounds
+            (if :attr:`method` switches to older algorithm).
+    """
+
+    if method == 'maximal':
+        return maximal_cusp_area_matrix(
+            manifold, bits_prec=bits_prec, verified=verified)
+    if method == 'maximalLegacy':
+        if not verified:
+            raise NotImplementedError("Maximal cusp area matrix only "
+                                      "available as verified computation. "
+                                      "Pass verified = True.")
+        return legacy_verified_maximal_cusp_area_matrix(
+            manifold, bits_prec=bits_prec)
+    if method in ['trigDependent', 'trigDependentTryCanonize']:
+        if method == 'trigDependentTryCanonize':
+            manifold = manifold.copy()
+            manifold.canonize()
+
+        return triangulation_dependent_cusp_area_matrix(
+            manifold, bits_prec=bits_prec, verified=verified)
+
+    raise ValueError("method passed to cusp_area_matrix must be "
+                       "'trigDependent', 'trigDependentTryCanonize', "
+                       "or 'maximal'.")
+

snappy/{verify/cusp_areas.py → cusps/cusp_areas_from_matrix.py}

@@ -1,28 +1,8 @@
-from ..sage_helper import _within_sage
-from .mathHelpers import interval_aware_min
+from ..math_basics import correct_min, is_RealIntervalFieldElement
 
 __all__ = ['unbiased_cusp_areas_from_cusp_area_matrix',
            'greedy_cusp_areas_from_cusp_area_matrix']
 
-if _within_sage:
-    from sage.rings.real_mpfi import is_RealIntervalFieldElement
-
-    # python's sqrt only work for floats
-    # They would fail or convert to float losing precision
-    from sage.all import sqrt
-else:
-    import math
-
-    # Otherwise, define our own sqrt which checks whether
-    # the given type defines a sqrt method and fallsback
-    # to python's log and sqrt which has the above drawback of
-    # potentially losing precision.
-    def sqrt(x):
-        if hasattr(x, 'sqrt'):
-            return x.sqrt()
-        return math.sqrt(x)
-
-
 def unbiased_cusp_areas_from_cusp_area_matrix(cusp_area_matrix):
     """
 
@@ -34,24 +14,25 @@ def unbiased_cusp_areas_from_cusp_area_matrix(cusp_area_matrix):
         ...                     [RIF(6.0,6.001 ),RIF(4.0, 4.001)]]))
         [3.00?, 2.000?]
 
-        >>> from snappy.SnapPy import matrix
+        >>> from snappy.number import Number, number_to_native_number
+        >>> def N(x): return number_to_native_number(Number(x))
+        >>> from snappy.matrix import make_matrix
         >>> unbiased_cusp_areas_from_cusp_area_matrix(
-        ...             matrix([[10.0, 40.0],
-        ...                     [40.0, 20.0]]))
+        ...             make_matrix([[N(10.0), N(40.0)],
+        ...                          [N(40.0), N(20.0)]])) # doctest: +NUMERIC9
         [3.1622776601683795, 4.47213595499958]
 
     """
 
-    if _within_sage:
-        if is_RealIntervalFieldElement(cusp_area_matrix[0, 0]):
-            return _verified_unbiased_cusp_areas_from_cusp_area_matrix(
-                cusp_area_matrix)
+    if is_RealIntervalFieldElement(cusp_area_matrix[0, 0]):
+        return _verified_unbiased_cusp_areas_from_cusp_area_matrix(
+            cusp_area_matrix)
 
     return _unverified_unbiased_cusp_areas_from_cusp_area_matrix(
                                                 cusp_area_matrix)
 
+
 def greedy_cusp_areas_from_cusp_area_matrix(cusp_area_matrix, first_cusps=[]):
-    
     """
 
         sage: from sage.all import matrix, RIF
@@ -60,27 +41,28 @@ def greedy_cusp_areas_from_cusp_area_matrix(cusp_area_matrix, first_cusps=[]):
         ...                     [RIF(6.0,6.001 ),RIF(10.0, 10.001)]]))
         [3.0001?, 2.000?]
 
-        >>> from snappy.SnapPy import matrix
+        >>> from snappy.number import Number, number_to_native_number
+        >>> def N(x): return number_to_native_number(Number(x))
+        >>> from snappy.matrix import make_matrix
         >>> greedy_cusp_areas_from_cusp_area_matrix(
-        ...             matrix([[10.0, 40.0],
-        ...                     [40.0, 20.0]]))
+        ...             make_matrix([[N(10.0), N(40.0)],
+        ...                          [N(40.0), N(20.0)]])) # doctest: +NUMERIC9
         [3.1622776601683795, 4.47213595499958]
-    
-    """
 
+    """
     num_cusps = cusp_area_matrix.dimensions()[0]
 
     result = list(range(num_cusps)) # Make space for range; initial values irrelevant
 
     # Cusp permutation given in Cayley notation
     sigma = first_cusps + [ i for i in range(num_cusps) if i not in first_cusps ]
-    
+
     for i in range(num_cusps):
         stoppers = [ cusp_area_matrix[sigma[i], sigma[j]] / result[sigma[j]]
                      for j in range(i) ]
-        self_stopper = sqrt(cusp_area_matrix[sigma[i], sigma[i]])
+        self_stopper = cusp_area_matrix[sigma[i], sigma[i]].sqrt()
 
-        result[sigma[i]] = interval_aware_min(stoppers + [ self_stopper ])
+        result[sigma[i]] = correct_min(stoppers + [ self_stopper ])
 
     return result
 
@@ -100,28 +82,31 @@ def _interval_minimum_candidates(intervals_and_extras):
 def _find_potential_stoppers(cusp_area_matrix, assigned_areas):
     def stopper(i, j):
         if not assigned_areas[i] is None:
-            return cusp_area_matrix[i,j] / assigned_areas[i]
+            return cusp_area_matrix[i, j] / assigned_areas[i]
         if not assigned_areas[j] is None:
-            return cusp_area_matrix[i,j] / assigned_areas[j]
-        return sqrt(cusp_area_matrix[i, j])
+            return cusp_area_matrix[i, j] / assigned_areas[j]
+        return cusp_area_matrix[i, j].sqrt()
 
     num_cusps = cusp_area_matrix.dimensions()[0]
 
-    return [ (stopper(i, j), (i, j))
-             for i in range(num_cusps)
-             for j in range(i, num_cusps)
-             if (assigned_areas[j] is None) or (assigned_areas[i] is None) ]
+    return [(stopper(i, j), (i, j))
+            for i in range(num_cusps)
+            for j in range(i, num_cusps)
+            if (assigned_areas[j] is None) or (assigned_areas[i] is None)]
+
 
 def _find_stoppers(cusp_area_matrix, assigned_areas):
     return _interval_minimum_candidates(
         _find_potential_stoppers(cusp_area_matrix, assigned_areas))
 
+
 def _union_intervals(intervals):
     result = intervals[0]
     for i in intervals[1:]:
         result = result.union(i)
     return result
 
+
 def _get_cusps_from_stoppers(stoppers, assigned_areas):
     result = set()
     for stopper in stoppers:
@@ -130,19 +115,19 @@ def _get_cusps_from_stoppers(stoppers, assigned_areas):
                 result.add(cusp)
     return result
 
-def _verified_unbiased_cusp_areas_from_cusp_area_matrix(
-                                                cusp_area_matrix):
+
+def _verified_unbiased_cusp_areas_from_cusp_area_matrix(cusp_area_matrix):
 
     num_cusps = cusp_area_matrix.dimensions()[0]
 
-    result = num_cusps * [ None ]
-    
+    result = num_cusps * [None]
+
     while None in result:
         stoppers = _find_stoppers(cusp_area_matrix, result)
 
-        stoppers_union = _union_intervals([ stopper[0] for stopper in stoppers ])
+        stoppers_union = _union_intervals([stopper[0] for stopper in stoppers])
         cusps = _get_cusps_from_stoppers(stoppers, result)
-        stopper_pairs = set([stopper[1] for stopper in stoppers])
+        stopper_pairs = {stopper[1] for stopper in stoppers}
 
         stop_size = (stoppers_union * stoppers_union) / stoppers_union
 
@@ -163,15 +148,16 @@ def _verified_unbiased_cusp_areas_from_cusp_area_matrix(
 
     return result
 
+
 def _find_minimal_stopper(cusp_area_matrix, assigned_areas):
     return min(_find_potential_stoppers(cusp_area_matrix, assigned_areas))
 
-def _unverified_unbiased_cusp_areas_from_cusp_area_matrix(
-                                                cusp_area_matrix):
+
+def _unverified_unbiased_cusp_areas_from_cusp_area_matrix(cusp_area_matrix):
     num_cusps = cusp_area_matrix.dimensions()[0]
     num_pending = num_cusps
 
-    result = num_cusps * [ None ]
+    result = num_cusps * [None]
 
     while num_pending > 0:
         stop_size, (i, j) = _find_minimal_stopper(cusp_area_matrix, result)
@@ -185,4 +171,3 @@ def _unverified_unbiased_cusp_areas_from_cusp_area_matrix(
                 num_pending -= 1
 
     return result
-