snappy 3.2__cp311-cp311-macosx_10_12_x86_64.whl

snappy/cache.py

@@ -0,0 +1,25 @@
+class SnapPyCache(dict):
+    """
+    Implementation of a simple cache used by the Manifold and Triangulation
+    to save the results of methods which require a significant amount of
+    computation.
+
+    This cache uses the tuple (method.__name, args, kwargs) as its key.
+    """
+    debug = False
+    _clear = dict.clear
+
+    def save(self, answer, method_name, *args, **kwargs):
+        self[(method_name, args, tuple(kwargs.items()))] = answer
+        return answer
+
+    def lookup(self, method_name, *args, **kwargs):
+        return self[(method_name, args, tuple(kwargs.items()))]
+
+    def clear(self, key=None, message=''):
+        if self.debug:
+            print('_clear_cache: %s' % message)
+        if key is None:
+            self._clear()
+        else:
+            self.pop(key)

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/cusps/__init__.py

@@ -0,0 +1,38 @@
+"""
+Computing data about cusps such as cusp matrix, shape, translations
+and exceptional slopes.
+"""
+
+from ..geometric_structure.cusp_neighborhood.complex_cusp_cross_section import ComplexCuspCrossSection
+from ..verify.shapes import compute_hyperbolic_shapes
+from ..exceptions import NonorientableManifoldError
+
+def compute_cusp_shapes(manifold, verified, bits_prec=None):
+    """
+    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.
+
+    >>> M = Manifold('s843')
+    >>> M.cusp_info('shape', bits_prec = 100) # doctest: +NUMERIC21
+    [0.46738227586341496791816972792 + 1.1903600506742881207098973751*I, 0.084187324414612694374797271558 + 1.0506945576790020048456757228*I]
+
+    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]
+    """
+
+    if not manifold.is_orientable():
+        raise NonorientableManifoldError(manifold)
+
+    shapes = compute_hyperbolic_shapes(
+        manifold, verified=verified, bits_prec=bits_prec)
+
+    # Compute cusp cross section
+    c = ComplexCuspCrossSection.fromManifoldAndShapes(manifold, shapes)
+
+    # Compute shape
+    return c.cusp_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/cusps/cusp_areas_from_matrix.py

@@ -0,0 +1,173 @@
+from ..math_basics import correct_min, is_RealIntervalFieldElement
+
+__all__ = ['unbiased_cusp_areas_from_cusp_area_matrix',
+           'greedy_cusp_areas_from_cusp_area_matrix']
+
+def unbiased_cusp_areas_from_cusp_area_matrix(cusp_area_matrix):
+    """
+
+    Examples::
+
+        sage: from sage.all import matrix, RIF
+        sage: unbiased_cusp_areas_from_cusp_area_matrix(
+        ...             matrix([[RIF(9.0,9.0005),RIF(6.0, 6.001)],
+        ...                     [RIF(6.0,6.001 ),RIF(4.0, 4.001)]]))
+        [3.00?, 2.000?]
+
+        >>> 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(
+        ...             make_matrix([[N(10.0), N(40.0)],
+        ...                          [N(40.0), N(20.0)]])) # doctest: +NUMERIC9
+        [3.1622776601683795, 4.47213595499958]
+
+    """
+
+    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
+        sage: greedy_cusp_areas_from_cusp_area_matrix(
+        ...             matrix([[RIF(9.0,9.0005),RIF(6.0, 6.001)],
+        ...                     [RIF(6.0,6.001 ),RIF(10.0, 10.001)]]))
+        [3.0001?, 2.000?]
+
+        >>> 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(
+        ...             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 = cusp_area_matrix[sigma[i], sigma[i]].sqrt()
+
+        result[sigma[i]] = correct_min(stoppers + [ self_stopper ])
+
+    return result
+
+
+def _interval_minimum_candidates(intervals_and_extras):
+    result = [intervals_and_extras[0]]
+    for this in intervals_and_extras[1:]:
+        t0 = this[0]
+        if not all(t0 > other[0] for other in result):
+            if all(t0 < other[0] for other in result):
+                result = [this]
+            else:
+                result.append(this)
+    return result
+
+
+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]
+        if not assigned_areas[j] is None:
+            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)]
+
+
+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:
+        for cusp in stopper[1]:
+            if assigned_areas[cusp] is None:
+                result.add(cusp)
+    return result
+
+
+def _verified_unbiased_cusp_areas_from_cusp_area_matrix(cusp_area_matrix):
+
+    num_cusps = cusp_area_matrix.dimensions()[0]
+
+    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])
+        cusps = _get_cusps_from_stoppers(stoppers, result)
+        stopper_pairs = {stopper[1] for stopper in stoppers}
+
+        stop_size = (stoppers_union * stoppers_union) / stoppers_union
+
+        for area in result:
+            if not area < stop_size:
+                raise Exception("New area smaller than existing areas")
+
+        for cusp in cusps:
+            result[cusp] = stop_size
+
+        for i in range(num_cusps):
+            for j in range(i, num_cusps):
+                if i in cusps or j in cusps:
+                    if (not result[i] is None) and (not result[j] is None):
+                        if not (i,j) in stopper_pairs:
+                            if not result[i] * result[j] < cusp_area_matrix[i,j]:
+                                raise Exception("Violated maximal cusp area", i, j)
+
+    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):
+    num_cusps = cusp_area_matrix.dimensions()[0]
+    num_pending = num_cusps
+
+    result = num_cusps * [None]
+
+    while num_pending > 0:
+        stop_size, (i, j) = _find_minimal_stopper(cusp_area_matrix, result)
+
+        if result[i] is None:
+            result[i] = stop_size
+            num_pending -= 1
+        if i != j:
+            if result[j] is None:
+                result[j] = stop_size
+                num_pending -= 1
+
+    return result