snappy 3.3__cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

snappy/cusps/cusp_areas_from_matrix.py

@@ -0,0 +1,96 @@
+from ..math_basics import correct_min, is_RealIntervalFieldElement, lower, upper
+
+__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.000?, 2.001?]
+
+        >>> 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]
+
+    """
+
+    verified = is_RealIntervalFieldElement(cusp_area_matrix[0, 0])
+    RIF = cusp_area_matrix[0,0].parent()
+
+    n = cusp_area_matrix.dimensions()[0]
+
+    sqrts = [ [ cusp_area_matrix[i, j].sqrt()
+                for j in range(n) ]
+              for i in range(n) ]
+
+    result = n * [ None ]
+
+    for _ in range(n):
+        lower_t_next, i = min(
+            ( lower(
+                sqrts[i][j]
+                if result[j] is None
+                else cusp_area_matrix[i, j] / result[j]),
+              i)
+            for i in range(n) if result[i] is None
+            for j in range(n) )
+        if verified:
+            lower_t_next_interval = RIF(lower_t_next)
+            upper_t_next = min(
+                upper(
+                    sqrts[i][i]
+                    if j == i
+                    else cusp_area_matrix[i, j] / (
+                            lower_t_next_interval
+                            if result[j] is None
+                            else result[j]))
+                for j in range(n) )
+            result[i] = RIF(lower_t_next, upper_t_next)
+        else:
+            result[i] = lower_t_next
+
+    return result
+
+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

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/short_slopes_for_cusp.py

@@ -0,0 +1,217 @@
+from ..sage_helper import _within_sage
+from ..exceptions import InsufficientPrecisionError
+from ..math_basics import is_RealIntervalFieldElement, is_ComplexIntervalFieldElement
+
+import math
+
+if _within_sage:
+    from ..sage_helper import gcd
+else:
+    # Python 3 has gcd in math
+    from math import gcd
+
+# Reject computing short slopes if intervals for translations
+# are too wide (error is more than 1%).
+_min_diameter_translations = 0.01
+
+def short_slopes_from_cusp_shape_and_area(
+        cusp_shape, cusp_area, length=6):
+    """
+    cusp_shape is longitude over meridian (conjugate).
+    l/m
+
+    sage: from sage.all import RIF, CIF
+    sage: short_slopes_from_cusp_shape_and_area(CIF(RIF(1.0),RIF(1.3333,1.3334)), RIF(12.0))
+    [(1, 0), (-2, 1), (-1, 1), (0, 1)]
+
+    >>> from snappy import number
+    >>> cusp_shape = number.number_to_native_number(number.Number(1.0+1.3333j))
+    >>> short_slopes_from_cusp_shape_and_area(cusp_shape, 12.0)
+    [(1, 0), (-2, 1), (-1, 1), (0, 1)]
+
+    """
+
+    return short_slopes_from_translations(
+        translations_from_cusp_shape_and_area(cusp_shape, cusp_area),
+        length)
+
+
+def translations_from_cusp_shape_and_area(
+        cusp_shape, cusp_area, kernel_convention=False):
+    """
+    Unfortunately, the short_slopes_from_translations uses the convention
+    that the longitude translation is real whereas the SnapPea kernel and
+    M.cusp_translations uses the convention that the meridian translation
+    is real. Thus, we have a flag here.
+
+    Ideally, we would rewrite below short_slopes_from_translations to
+    use the same convention.
+    """
+
+    if kernel_convention:
+        inv_cusp_shape = 1 / cusp_shape.conjugate()
+        scale = (cusp_area / _imag(inv_cusp_shape)).sqrt()
+        return (scale * inv_cusp_shape, scale)
+    else:
+        scale = (cusp_area / _imag(cusp_shape)).sqrt()
+        return (scale, cusp_shape * scale)
+
+def short_slopes_from_translations(translations, length=6):
+
+    m_tran, l_tran = translations
+
+    if is_ComplexIntervalFieldElement(m_tran):
+        raise Exception("Meridian translation expected to be real")
+    if is_RealIntervalFieldElement(l_tran):
+        raise Exception("Longitude translation expected to be complex")
+
+    is_interval_1 = is_RealIntervalFieldElement(m_tran)
+    is_interval_2 = is_ComplexIntervalFieldElement(l_tran)
+
+    if is_interval_1 != is_interval_2:
+        raise Exception("Mismatch of non-intervals and intervals.")
+
+    if is_interval_1:
+        return _verified_short_slopes_from_translations(translations, length)
+
+    return _unverified_short_slopes_from_translations(translations, length)
+
+_safety_factor = 1.001
+
+def _unverified_short_slopes_from_translations(translations, length=6):
+    m_tran, l_tran = translations
+
+    if m_tran.imag() != 0.0:
+        raise Exception("Expected real meridian translation")
+
+    if not m_tran > 0:
+        raise Exception("Expected positive meridian translation")
+
+    RF = l_tran.real().parent()
+
+    length = RF(length * RF(_safety_factor))
+
+    result = []
+    max_abs_l = _floor(length / abs(_imag(l_tran)))
+
+    for l in range(max_abs_l + 1):
+        total_l_tran = l * l_tran
+
+        max_real_range_sqr = length ** 2 - _imag(total_l_tran) ** 2
+
+        if max_real_range_sqr >= 0:
+            max_real_range = max_real_range_sqr.sqrt()
+
+            if l == 0:
+                min_m = 1
+            else:
+                min_m = _ceil(
+                    (- _real(total_l_tran) - max_real_range) / m_tran)
+
+            max_m = _floor(
+                (- _real(total_l_tran) + max_real_range) / m_tran)
+
+            for m in range(min_m, max_m + 1):
+                if gcd(m, l) in [-1, +1]:
+                    result.append((m, l))
+
+    return result
+
+
+def _verified_short_slopes_from_translations(translations, length=6):
+    m_tran, l_tran = translations
+
+    if not m_tran > 0:
+        raise Exception("Expected positive meridian translation.")
+
+    if not l_tran.imag() != 0:
+        raise InsufficientPrecisionError(
+            "Could not verify that longitude meridian translation "
+            "has non-trivial imaginary part.")
+
+    if m_tran.diameter() > _min_diameter_translations:
+        raise InsufficientPrecisionError(
+            "Meridian translation has insufficient precision to compute "
+            "a reasonable set of short slopes.")
+
+    if l_tran.diameter() > _min_diameter_translations:
+        raise InsufficientPrecisionError(
+            "Longitude translation has insufficient precision to compute "
+            "a reasonable set of short slopes.")
+
+    RIF = m_tran.parent()
+
+    length = RIF(length)
+
+    result = []
+
+    max_abs_l = _max_int_in_interval(length / abs(l_tran.imag()))
+
+    for l in range(max_abs_l + 1):
+        total_l_tran = l * l_tran
+
+        max_real_range_sqr = (length ** 2 - total_l_tran.imag() ** 2).upper()
+
+        if max_real_range_sqr >= 0:
+            max_real_range = RIF(max_real_range_sqr).sqrt()
+
+            if l == 0:
+                min_m = 1
+            else:
+                min_m = _min_int_in_interval(
+                    (- total_l_tran.real() - max_real_range) / m_tran)
+
+            max_m = _max_int_in_interval(
+                (- total_l_tran.real() + max_real_range) / m_tran)
+
+            for m in range(min_m, max_m + 1):
+                if gcd(m, l) in [+1, -1]:
+                    result.append((m, l))
+
+    return result
+
+
+def _max_int_in_interval(i):
+    return i.upper().floor()
+
+
+def _min_int_in_interval(i):
+    return i.lower().ceil()
+
+
+def _real(x):
+    if isinstance(x, complex):
+        return x.real
+    return x.real()
+
+
+def _imag(x):
+    if isinstance(x, complex):
+        return x.imag
+    return x.imag()
+
+
+def _floor(x):
+    if isinstance(x, float):
+        return math.floor(x)
+    return int(x.floor())
+
+
+def _ceil(x):
+    if isinstance(x, float):
+        return math.ceil(x)
+    return int(x.ceil())
+
+def _dummy_for_tests():
+    """
+    >>> M = Manifold("m004")
+    >>> M.short_slopes()
+    [[(1, 0), (-4, 1), (-3, 1), (-2, 1), (-1, 1), (0, 1), (1, 1), (2, 1), (3, 1), (4, 1)]]
+
+    >>> M.high_precision().short_slopes()
+    [[(1, 0), (-4, 1), (-3, 1), (-2, 1), (-1, 1), (0, 1), (1, 1), (2, 1), (3, 1), (4, 1)]]
+
+    sage: M.short_slopes(verified=True)
+    [[(1, 0), (-4, 1), (-3, 1), (-2, 1), (-1, 1), (0, 1), (1, 1), (2, 1), (3, 1), (4, 1)]]
+
+    """

snappy/cusps/test.py

@@ -0,0 +1,22 @@
+from snappy import testing
+import snappy
+
+from snappy import cusps
+
+modules = [
+    cusps,
+    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)])