snappy 3.1.1__cp38-cp38-win_amd64.whl → 3.2__cp38-cp38-win_amd64.whl

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,26 +1,8 @@
-from ..sage_helper import _within_sage
 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:
-    # 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):
     """
 
@@ -32,10 +14,12 @@ 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]
 
     """
@@ -57,10 +41,12 @@ 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]
 
     """
@@ -74,7 +60,7 @@ def greedy_cusp_areas_from_cusp_area_matrix(cusp_area_matrix, 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]] = correct_min(stoppers + [ self_stopper ])
 
@@ -96,17 +82,17 @@ 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):
@@ -130,19 +116,18 @@ def _get_cusps_from_stoppers(stoppers, assigned_areas):
     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
 
@@ -168,8 +153,7 @@ 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
 

snappy/cusps/maximal_cusp_area_matrix.py

@@ -0,0 +1,136 @@
+from ..geometric_structure.cusp_neighborhood.tiles_for_cusp_neighborhood import (
+    mcomplex_for_tiling_cusp_neighborhoods)
+from ..tiling.tile import Tile
+
+from ..matrix import make_matrix
+from ..sage_helper import _within_sage
+from ..math_basics import correct_min, is_RealIntervalFieldElement, lower
+
+from ..hyperboloid.distances import distance_r13_horoballs
+
+if _within_sage:
+    from ..sage_helper import Infinity
+
+def maximal_cusp_area_matrix(manifold, bits_prec, verified):
+    """
+    A test case that hits both the tiling case and the early bail case
+    (using v.exp_self_distance_along_edges):
+    
+    >>> from snappy import Manifold
+    >>> M = Manifold("o9_44206")
+    >>> maximal_cusp_area_matrix(M, bits_prec=53, verified=False) # doctest: +NUMERIC9
+    [88.4588035788544 14.3590180492058 11.4136568679715 9.67661682098105]
+    [14.3590180492058 88.4588035788533 9.67661682098102 11.4136568679705]
+    [11.4136568679715 9.67661682098102 88.4588035788541 14.3590180492042]
+    [9.67661682098105 11.4136568679705 14.3590180492042 88.4588035788038]
+
+    sage: from snappy import Manifold
+    sage: M = Manifold("o9_44206")
+    sage: maximal_cusp_area_matrix(M, bits_prec=80, verified=True) # doctest: +NUMERIC6
+    [ 88.458803578854197094? 14.3590180492058335371? 11.4136568679715291317?  9.6766168209810445566?]
+    [14.3590180492058335371?          88.4588035789?      9.676616820981044?          11.4136568680?]
+    [11.4136568679715291317?      9.676616820981044?      88.45880357885420?         14.35901804921?]
+    [ 9.6766168209810445566?          11.4136568680?         14.35901804921?           88.458803578?]
+    """
+
+    mcomplex = mcomplex_for_tiling_cusp_neighborhoods(
+        manifold, bits_prec=bits_prec, verified=verified)
+
+    n = len(mcomplex.Vertices)
+
+    lower_entries = [
+        [ _entry(mcomplex, i, j) for j in range(i + 1) ]
+        for i in range(n) ]
+
+    return make_matrix(
+        [[ lower_entries[i][j] if j < i else lower_entries[j][i]
+           for j in range(n) ]
+         for i in range(n) ])
+
+def _entry(mcomplex, i, j):
+    p = mcomplex.Vertices[i].cusp_area * mcomplex.Vertices[j].cusp_area
+
+    if i == j:
+        return p * _diagonal_scale(mcomplex, i)
+    else:
+        return p * _non_diagonal_scale(mcomplex, i, j)
+
+def _diagonal_scale(mcomplex, i):
+    v = mcomplex.Vertices[i]
+    e = v.exp_self_distance_along_edges
+    if not e is None:
+        if e < v.scale_for_std_form ** 2:
+            return e ** 2
+
+    if mcomplex.verified:
+        d = mcomplex.RF(Infinity)
+    else:
+        d = mcomplex.RF(1e20)
+
+    tet_to_lifts = [ [] for tet in mcomplex.Tetrahedra ]
+
+    for tile in v.tiles():
+        if tile.lower_bound_distance > d / 2:
+            return (2 * d).exp() # Area, so need square
+
+        new_lift = tile.inverse_lifted_geometric_object.defining_vec
+
+        tet_index = tile.lifted_tetrahedron.tet.Index
+
+        lifts = tet_to_lifts[tet_index]
+        for lift in lifts:
+            d = correct_min([d,
+                             distance_r13_horoballs(new_lift, lift)])
+        lifts.append(new_lift)
+
+def _non_diagonal_scale(mcomplex, i, j):
+    v0 = mcomplex.Vertices[i]
+    v1 = mcomplex.Vertices[j]
+    c = mcomplex.real_cusp_cross_section
+    e = c.exp_distance_neighborhoods_measured_along_edges(i, j)
+    if not e is None:
+        if e < v0.scale_for_std_form * v1.scale_for_std_form:
+            return e ** 2
+
+    if mcomplex.verified:
+        d = mcomplex.RF(Infinity)
+    else:
+        d = mcomplex.RF(1e20)
+
+    obj_to_tet_to_lifts = [ [ [] for tet in mcomplex.Tetrahedra ]
+                            for i in range(2) ]
+
+    for tile in _merge_tiles([v0.tiles(), v1.tiles()]):
+        if tile.lower_bound_distance > d:
+            return (2 * d).exp()
+
+        new_lift = tile.inverse_lifted_geometric_object.defining_vec
+        tet_index = tile.lifted_tetrahedron.tet.Index
+
+        for lift in obj_to_tet_to_lifts[1 - tile.object_index][tet_index]:
+            d = correct_min([d,
+                             distance_r13_horoballs(new_lift, lift)])
+        obj_to_tet_to_lifts[tile.object_index][tet_index].append(new_lift)
+
+def _merge_tiles(streams_of_tiles):
+
+    iters = [ iter(s) for s in streams_of_tiles ]
+    tiles = [ next(iter) for iter in iters ]
+
+    while True:
+        i = _argmin(*(lower(tile.lower_bound_distance) for tile in tiles))
+        tile = tiles[i]
+        yield Tile(
+            # Relying on -inf + x = -inf
+            sum(t.lower_bound_distance for t in tiles),
+            tile.inverse_lifted_geometric_object,
+            tile.lifted_tetrahedron,
+            i)
+
+        tiles[i] = next(iters[i])
+
+def _argmin(v0, v1):
+    if v0 < v1:
+        return 0
+    else:
+        return 1

snappy/cusps/test.py

@@ -0,0 +1,21 @@
+from snappy import testing
+import snappy
+
+from snappy import cusps
+
+modules = [
+    cusps.maximal_cusp_area_matrix,
+    cusps.cusp_areas_from_matrix
+]
+
+def run_doctests(verbose=False, print_info=True):
+    globs = {'Manifold': snappy.Manifold}
+    return testing.doctest_modules(modules,
+                                   verbose=verbose,
+                                   print_info=print_info,
+                                   extraglobs=globs)
+
+run_doctests.__name__ = cusps.__name__
+
+if __name__ == '__main__':
+    testing.run_doctests_as_main(run_doctests)

snappy/cusps/trig_cusp_area_matrix.py

@@ -0,0 +1,63 @@
+from ..geometric_structure.cusp_neighborhood.real_cusp_cross_section import RealCuspCrossSection
+from ..math_basics import correct_min
+from ..verify.shapes import compute_hyperbolic_shapes
+from ..matrix import make_matrix
+
+__all__ = ['triangulation_dependent_cusp_area_matrix',
+           'triangulation_dependent_cusp_area_matrix_from_cusp_cross_section']
+
+def triangulation_dependent_cusp_area_matrix(
+                            snappy_manifold, bits_prec, verified):
+    """
+    Interesting case: t12521
+
+    Maximal cusp area matrix:
+
+    [ 77.5537626509970512653317518641810890989543820290380458409? 11.40953140648583915022197187043644048603871960228564151087?]
+    [11.40953140648583915022197187043644048603871960228564151087?     91.1461442179608339668518063027198489593908228325190920?]
+
+    This result:
+
+    [  77.553762651?   11.409531407?]
+    [  11.409531407? 5.508968850234?]
+
+    After M.canonize:
+
+    [  62.42018359?  11.409531407?]
+    [ 11.409531407? 15.1140644993?]
+    """
+    # Get shapes, as intervals if requested
+    shapes = compute_hyperbolic_shapes(
+        snappy_manifold, verified=verified, bits_prec=bits_prec)
+
+    # Compute cusp cross section, the code is agnostic about whether
+    # the numbers are floating-point or intervals.
+    #
+    # Note that the constructed cusp cross section will always be too "large"
+    # and we need to scale them down (since during construction the
+    # cross-section of each cusp will have one edge of length 1, the
+    # corresponding tetrahedron does not intersect in "standard" form.)
+
+    return triangulation_dependent_cusp_area_matrix_from_cusp_cross_section(
+        RealCuspCrossSection.fromManifoldAndShapes(snappy_manifold, shapes))
+
+def triangulation_dependent_cusp_area_matrix_from_cusp_cross_section(c):
+
+    # Scale (up or down) all the cusps so that they are in standard form.
+    c.ensure_std_form(allow_scaling_up=True)
+
+    areas = c.cusp_areas()
+    RIF = areas[0].parent()
+
+    def entry(i, j):
+        result = areas[i] * areas[j]
+
+        d = c.exp_distance_neighborhoods_measured_along_edges(i, j)
+        if d is not None:
+            result *= correct_min([ RIF(1), d ]) ** 2
+        return result
+
+    n = len(areas)
+
+    return make_matrix([[entry(i, j) for i in range(n)]
+                        for j in range(n)])

snappy/database.py

@@ -22,17 +22,17 @@ import importlib
 import collections
 
 if _within_sage:
-    import sage.all
+    from .sage_helper import Integer, RealDoubleElement, RealNumber
 
     def is_int(slice):
-        return isinstance(slice, (sage.all.Integer, int))
+        return isinstance(slice, (Integer, int))
 
     def is_int_or_none(slice):
-        return isinstance(slice, (sage.all.Integer, int, type(None)))
+        return isinstance(slice, (Integer, int, type(None)))
 
     def is_float_or_none(slice):
-        return isinstance(slice, (float, sage.all.RealDoubleElement,
-                                  sage.rings.real_mpfr.RealNumber, type(None)))
+        return isinstance(slice, (float, RealDoubleElement,
+                                  RealNumber, type(None)))
 else:
     def is_int(slice):
         return isinstance(slice, int)
@@ -98,6 +98,7 @@ class ManifoldTable():
                  mfld_hash=mfld_hash, **filter_args):
         self._table = table
         self.mfld_hash = mfld_hash
+        self._db_path = db_path
         self._connection = connect_to_db(db_path)
         self._cursor = self._connection.cursor()
         self._set_schema()
@@ -110,7 +111,7 @@ class ManifoldTable():
     def _set_schema(self):
         cursor, table = self._cursor, self._table
         rows = cursor.execute("pragma table_info('%s')" % table).fetchall()
-        self.schema = dict([(row[1], row[2].lower()) for row in rows])
+        self.schema = {row[1]: row[2].lower() for row in rows}
 
     def _check_schema(self):
         assert (self.schema['name'] == 'text' and
@@ -390,7 +391,7 @@ class ManifoldTable():
                 except RuntimeError:
                     pass
 
-        mfld = mflds[0]
+        mfld = Triangulation(mflds[0]) # Drop the hyperbolic structure
         # Check for identical triangulations.
         if (False not in mfld.cusp_info('is_complete')) and not extends_to_link:
             for n in range(100):
@@ -431,7 +432,7 @@ def add_tables_from_package(package_name, must_succeed=True):
         package = importlib.import_module(package_name)
     except ImportError:
         if not must_succeed:
-            return dict()
+            return {}
         else:
             raise ImportError('ManifoldTable package %s not found'
                               % package_name)
@@ -446,7 +447,7 @@ def add_tables_from_package(package_name, must_succeed=True):
     # We also store the tables here so that their doctests can be
     # checked.
     if not hasattr(this_module, '__test__'):
-        this_module.__test__ = dict()
+        this_module.__test__ = {}
     for name, table in new_tables.items():
         this_module.__test__[name] = table.__class__