snappy 3.3__cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

snappy/len_spec/geometry.py

@@ -0,0 +1,136 @@
+from ..hyperboloid.distances import cosh_distance_r13_point_line
+from ..hyperboloid import r13_dot
+from ..math_basics import correct_min, correct_max # type: ignor
+from ..exceptions import InsufficientPrecisionError
+
+from ..snap.t3mlite import simplex, Tetrahedron
+
+from typing import Optional, Any
+
+def lower_bound_geodesic_length(
+        lower_bound_cosh_distance, inv_spine_cosh):
+    """
+    This implements a version of Proposition 3.5 of
+    Weeks-Hodgson's Symmetries, Isometries and Length Spectra of Closed
+    Hyperbolic Three-Manifolds. Slightly changing notation, it says:
+
+        To find all closed geodesics of length at most L, it sufficies to
+        find all translates gD such that d(x, gx) <= R where
+                   R = 2 arccosh(cosh(r) cosh(L/2)).
+
+    The input is a lower_bound_distance, a lower bound on the radius R of the
+    ball we have covered by tiles, and inv_spine_cosh = 1/cosh(r) where
+    r is a given tetrahedron's spine radius. More precisely, r is the radius
+    with respect to a given's tetrahedron's spine center (typically incenter)
+    of the intersection of the triangulation's spine with the tetrahedron.
+
+    The output is L which has the following property: Any geodesic in M that
+    intersects the given tetrahedron's spine and has length less than L is
+    among the ones we have encountered during tiling so far.
+
+    Note that our R is defined slightly differently, thus we can actually drop
+    the factor of 2 through out:
+
+                  R = arccosh(cosh(r) cosh(L))
+
+    We also want an expression in L:
+
+                  L = arccosh(cosh(R) / cosh(r))
+
+    And want to conservatively return 0 if this is not well-defined.
+
+    Note that we use the tetrahedron's spine radius here. But since we are
+    interested in geodesics and length bounds intrinsic to the manifold, the
+    length spectrum computation starts a tiling process for each tetrahedron.
+
+    Note that if the geometric structure is complete, every geodesic
+    will intersect the spine. However, for a spun-triangulation, this
+    only applies to geodesics that are not core curves. This is fine
+    since we treat core curves separately when computing the length
+    spectrum.
+    """
+
+    if lower_bound_cosh_distance > 1:
+        q = lower_bound_cosh_distance * inv_spine_cosh
+        if q > 1:
+            return q.arccosh()
+    RF = lower_bound_cosh_distance.parent()
+    return RF(0)
+
+def lower_bound_cosh_distance_r13_point_truncated_tetrahedron(
+        point, tet : Tetrahedron, *, verified : bool):
+
+    """
+    A lower bound for cosh of the distance of a point to a truncated
+    tetrahedron tet. Assumes the point is outside the truncated tetrahedron.
+
+    The truncated tetrahedron is given as follows: ideal triangles
+    tet.R13_triangles[f] for each face forming the ideal tetrahedron
+    underlying the truncated tetrahedron, a lower bound tet.out_radius
+    of the truncated tetrahedron about its spine center (which is the
+    ideal tetrahedron's incenter).
+    """
+
+    # We compute one lower bound from the distance to the ideal tetrahedron.
+    #
+    # Ignore (irrelevant) contributions to the min from those faces 
+    # where the associated half-space does not contain the point.
+    cosh_d_faces = _min([
+        cosh_d
+        for f in simplex.TwoSubsimplices
+        if (cosh_d := lower_bound_cosh_distance_r13_point_triangle(
+                point, tet.R13_triangles[f], verified=verified)) is not None ])
+
+    # We compute the other lower bound as
+    #
+    # d_out   = distance_r13_points(point, tet.spine_center) - tet.out_radius
+    #
+    # We use trigonometric inequalities to avoid evaluating transcendentals.
+    cosh_d_spine_center = -r13_dot(point, tet.spine_center)
+    if not cosh_d_spine_center > tet.cosh_out_radius:
+        # Only use the second lower bound if d_out has positive sign.
+        return cosh_d_faces
+
+    sinh_d_spine_center = (cosh_d_spine_center ** 2 - 1).sqrt()
+    cosh_d_out = (cosh_d_spine_center * tet.cosh_out_radius -
+                  sinh_d_spine_center * tet.sinh_out_radius)
+
+    if not cosh_d_out > 1:
+        return cosh_d_faces
+
+    return correct_max([cosh_d_out, cosh_d_faces])
+
+def lower_bound_cosh_distance_r13_point_triangle(
+        point, triangle, *, verified : bool) -> Optional[Any]:
+    """
+    Return None if associated half-space does not contain the point.
+    """
+
+    if verified:
+        epsilon = 0
+    else:
+        RF = point[0].parent()
+        epsilon = _compute_epsilon(RF)
+
+    sinh_dist_point_plane = r13_dot(point, triangle.plane)
+    if sinh_dist_point_plane <= -epsilon:
+        return None
+    for bounding_plane, edge in zip(triangle.bounding_planes,
+                                    triangle.edges):
+        if r13_dot(point, bounding_plane) > epsilon:
+            return cosh_distance_r13_point_line(point, edge)
+
+    return (sinh_dist_point_plane ** 2 + 1).sqrt()
+
+def _compute_epsilon(RF):
+    return RF(0.5) ** (RF.prec() // 2)
+
+def _min(values):
+    n = len(values)
+    if n == 0:
+        raise InsufficientPrecisionError(
+            "Could not verify point outside of tetrahedron.")
+    elif n == 1:
+        return values[0]
+    else:
+        return correct_min(values)

snappy/len_spec/length_spectrum_geodesic_info.py

@@ -0,0 +1,185 @@
+from ..SnapPy import Info
+from ..math_basics import (
+    is_RealIntervalFieldElement,
+    is_ComplexIntervalFieldElement)
+
+from typing import Tuple, Optional
+
+class LengthSpectrumGeodesicInfo(Info):
+    """
+    Information about a geodesic in the length spectrum as returned by
+    Manifold.length_spectrum_alt_gen.
+    """
+
+    def _body(self) -> str:
+        if self._is_intermediate:
+            return _format_intermediate % (
+                _format_real_length(self.length.real()))
+        else:
+            return _format % (
+                _format_length(self.length),
+                _format_core_curve(self.core_curve),
+                self.word)
+
+    def __repr__(self) -> str:
+        if self._is_first:
+            return _header + '\n' + self._body()
+        else:
+            return self._body()
+
+_core_curve_label = 'Core curve'
+_verified_num_digits = 19
+
+_format = (
+    '%%-%ds '        # Length
+    '%%-%ds  '       # Core curve
+    '%%s'            # Word
+    ) % (_verified_num_digits + len(' + ') + _verified_num_digits + len('*I'),
+         len(_core_curve_label))
+
+_format_intermediate = (
+    '                     Up to length %%-%ds' % _verified_num_digits)
+
+_format_unverified_real = "%16.14f"
+
+_header = _format % ( 'Length',
+                      _core_curve_label,
+                      'Word')
+
+_total_length = len("Out [100:] " + _header)
+
+if _total_length > 80:
+    raise AssertionError(
+        "Total length spectrum string too long: %d" % (
+            _total_length))
+
+def _format_length(length) -> str:
+    if is_ComplexIntervalFieldElement(length):
+        return _format_verified_length(length)
+    else:
+        return _format_unverified_length(length)
+
+def _format_verified_length(length) -> str:
+    return (
+        _format_verified_real_length(length.real()) +
+        ' ' +
+        _format_verified_imag_length(length.imag()) +
+        '*I')
+
+def _format_verified_real_length(length) -> str:
+    result = repr(length)
+    return _make_fixed_length(result, _verified_num_digits)
+
+def _format_verified_imag_length(length) -> str:
+    result = repr(length)
+
+    # Consume "-" to consistently format " + " and " - " later.
+    has_minus = result[0] == '-'
+    if has_minus:
+        result = result[1:]
+
+    # If this appears to be zero
+    # (that is small enough that it is of the form 1.0?e-10
+    #  and cannot be verified to be non-zero), then
+    # we write "0.00000?" or "0.00000....".
+    if 'e' in result and not length != 0:
+        num_zeros = (-abs(length).log10()).lower().floor()
+        if num_zeros > 2:
+            result = '0.' + num_zeros * '0' + '?'
+
+    result = _make_fixed_length(result, _verified_num_digits)
+
+    if has_minus:
+        result = '- ' + result
+    else:
+        result = '+ ' + result
+    return result
+
+def _format_unverified_length(length) -> str:
+    lenStr = _format_unverified_real % length.real()
+    absImag = abs(length.imag())
+    # Unverified: just drop imaginary part if it is close to zero.
+    if absImag > 1e-9:
+        if length.imag() > 0:
+            lenStr += " + "
+        else:
+            lenStr += " - "
+        lenStr += (_format_unverified_real % absImag) + "*I"
+    return lenStr
+
+def _format_word(word : str, max_length : int) -> str:
+    """
+    >>> _format_word('abcdefghi', 9)
+    'abcdefghi'
+    >>> _format_word('abcdefghi', 8)
+    'abcde...'
+    >>> _format_word('X1x2x123x12', 11)
+    'X1x2x123x12'
+    >>> _format_word('X1x2x123x12', 10)
+    'X1x2...'
+    """
+
+    if len(word) <= max_length:
+        return word
+
+    # If word is too long, write it as "abc..." so that total
+    # length is _max_word_length.
+    ellipsis = '...'
+
+    for i in range(max_length - len(ellipsis), -1, -1):
+        # Be careful not to break at, say 2, in x123 since
+        # x12... would be misleading.
+        if not word[i].isdigit():
+            break
+    return word[:i] + ellipsis
+
+def _format_core_curve(core_curve : Optional[int]) -> str:
+    if core_curve is None:
+        return '-'
+    else:
+        return 'Cusp %d' % core_curve
+
+def _format_real_length(length):
+    if is_RealIntervalFieldElement(length):
+        return _format_verified_real_length(length.real())
+    else:
+        return _format_unverified_real % length.real()
+    
+def _split_scientific_notation(s : str) -> Tuple[str, str]:
+    """
+    >>> _split_scientific_notation('0.45')
+    ('0.45', '')
+    >>> _split_scientific_notation('4.5?e-5')
+    ('4.5?', 'e-5')
+    """
+
+    parts = s.split('e', 2)
+    if len(parts) == 2:
+        return parts[0], 'e' + parts[1]
+    else:
+        return parts[0], ''
+
+def _make_fixed_length(result : str, length : int) -> str:
+    """
+    >>> _make_fixed_length('0.1234567', 9)
+    '0.1234567'
+    >>> _make_fixed_length('0.1234567', 8)
+    '0.123...'
+    >>> _make_fixed_length('1.2345678e-4', 9)
+    '1.2...e-4'
+    """
+
+    n = len(result)
+
+    # How many characters to we need to erase.
+    k = n - length
+
+    if k <= 0:
+        # We actually need to fill with white space.
+        return result + (-k) * ' '
+
+    # Preserve trailing, e.g., 'e-4'
+    m, e = _split_scientific_notation(result)
+    ellipsis = '...'
+    k += len(ellipsis)
+    return m[:-k] + ellipsis + e

snappy/len_spec/spine.py

@@ -0,0 +1,128 @@
+from ..snap.t3mlite import Mcomplex, simplex, Tetrahedron
+from ..hyperboloid.distances import distance_r13_points
+from ..hyperboloid import compute_inradius_and_incenter_from_planes
+from ..hyperboloid import time_r13_normalise, r13_dot
+from ..math_basics import correct_max
+
+def add_spine(mcomplex : Mcomplex):
+    """
+    Adds a spine to the mcomplex with some geometric structures.
+
+    The key property of the spine is that every geodesic that is not a core
+    curve is intersecting the spine.
+
+    Topologically, the spine is the dual 2-skeleton of the triangulation.
+    Restricted to a tetrahedron, it consists of 12 triangles. The vertices
+    of each triangle are on an edge, on a face and inside the tetrahedron.
+
+    We can give the spine a geometry by picking a point on each edge, on
+    each face and in each tetrahedron. Since we are only interested in the
+    radius of the spine when restricted to a tetrahedron, we actually do
+    not explicitly compute a point for each face.
+
+    We store the following information about the spine:
+    - use the tetrahedron's incenter as its spine center tet.spine_center.
+    - compute tet.out_radius, the radius (about the spine center) of a
+      tetrahedron truncated by the generalized cusp neighborhoods (that is
+      cusp neighborhoods for complete cusps and tubes about core curves
+      for incomplete cusps).
+    - points on the edges of the triangulation, stored in tet.spine_points.
+    - the maximum distance of the tet.spine_points to tet.spine_center in
+      tet.spine_radius.
+    - tet.inv_spine_cosh = 1 / cosh(r) where r is the tet.spine_radius
+    - for the entire fundamental domain, we store a global spine center
+      and radius in mcomplex.spine_center and mcomplex.spine_radius.
+    """
+
+    for tet in mcomplex.Tetrahedra:
+        if False:
+            for v in simplex.ZeroSubsimplices:
+                d = r13_dot(tet.spine_center, tet.R13_vertices[v])
+                if not d < - (1 - mcomplex.RF(1e-8)):
+                    print(tet.spine_points)
+                    print(tet.R13_vertices)
+                    raise Exception("Conjecture is wrong.")
+
+        tet.out_points = {
+            (v0, v1): _out_point(tet, v0, v1)
+            for v0 in simplex.ZeroSubsimplices
+            for v1 in simplex.ZeroSubsimplices
+            if v0 != v1 }
+
+        tet.spine_points = {
+            v0 | v1: time_r13_normalise(
+                tet.out_points[(v0, v1)] + tet.out_points[(v1, v0)])
+            for v0 in simplex.ZeroSubsimplices
+            for v1 in simplex.ZeroSubsimplices
+            if v0 < v1 }
+
+        for v0 in simplex.ZeroSubsimplices:
+            if tet.Class[v0].is_complete:
+                continue
+            for v1 in simplex.ZeroSubsimplices:
+                if v0 == v1:
+                    continue
+                e = v0 | v1
+                mu_v0v1 = tet.horotriangles[v0].inverse_scale_to_be_on_tube[e]
+                mu_v1v0 = tet.horotriangles[v1].inverse_scale_to_be_on_tube[e]
+                f = simplex.RightFace[e]
+                a = tet.horotriangles[v0].get_real_lengths()[f]
+                b = tet.horotriangles[v1].get_real_lengths()[f]
+
+                # mu_v0v1 / mu_v1v0 < 1 / (a * b)
+                if mu_v0v1 * a * b < mu_v1v0:
+                    continue
+
+                tet.spine_points[v0, v1] = _point_on_horosphere(tet.R13_vertices[v0], tet.R13_vertices[v1])
+
+        _, tet.spine_center = compute_inradius_and_incenter_from_planes(
+            [ tet.R13_planes[f]
+              for f in simplex.TwoSubsimplices ])
+
+        tet.spine_radius = correct_max(
+            [ distance_r13_points(tet.spine_center, p)
+              for e, p in tet.spine_points.items() ])
+
+        tet.inv_spine_cosh = 1 / tet.spine_radius.cosh()
+
+        tet.out_radius = correct_max(
+            [ distance_r13_points(tet.spine_center,
+                                  tet.out_points[(v0, v1)])
+              for v0 in simplex.ZeroSubsimplices
+              for v1 in simplex.ZeroSubsimplices
+              if v0 != v1 ])
+
+        tet.cosh_out_radius = tet.out_radius.cosh()
+        tet.sinh_out_radius = tet.out_radius.sinh()
+
+        if False:
+            print("out, spine =", tet.out_radius, tet.spine_radius)
+
+    mcomplex.spine_center = mcomplex.baseTet.spine_center
+    mcomplex.spine_radius = correct_max(
+        [ tet.spine_radius + distance_r13_points(
+            mcomplex.spine_center, tet.spine_center)
+          for tet in mcomplex.Tetrahedra ])
+
+def _out_point(tet : Tetrahedron, v0 : int, v1 : int):
+    """
+    Compute one vertex of the tetrahedron truncated by a neighborhood
+    in the cusp or about a core curve.
+    """
+
+    # Recall that the vertices defining horospheres truncating the tetrahedron
+    # so much that it is just touching the neighborhood without intersecting
+    # it.
+    #
+    # We apply the scale so that the vertex is on the boundary of the
+    # neighborhood.
+
+    s = tet.horotriangles[v0].inverse_scale_to_be_on_tube[v0 | v1]
+    return _point_on_horosphere(s * tet.R13_vertices[v0], tet.R13_vertices[v1])
+
+def _point_on_horosphere(horo_vec, pt):
+    """
+    The point that is the intersection of the horosphere defined by horo_vec
+    and the line from horo_vec to pt.
+    """
+    return time_r13_normalise( horo_vec - (2 / r13_dot(horo_vec, pt)) * pt)

snappy/len_spec/test.py

@@ -0,0 +1,24 @@
+from snappy import testing
+import snappy
+
+from snappy import len_spec
+import snappy.len_spec.test_cases
+
+modules = [
+    len_spec,
+    len_spec.word,
+    len_spec.length_spectrum_geodesic_info,
+    len_spec.test_cases
+]
+
+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__ = len_spec.__name__
+
+if __name__ == '__main__':
+    testing.run_doctests_as_main(run_doctests)

snappy/len_spec/test_cases.py

@@ -0,0 +1,69 @@
+"""
+IMPORTANT: Python only recognises this as a doc string if there is
+nothing before it. In particular, add any includes after the doc string.
+
+>>> M = Manifold("m125(3,4)(0,0)")
+>>> spec = M.length_spectrum_alt_gen()
+>>> next(spec) # doctest: +NUMERIC9
+Length                                      Core curve  Word
+0.24208261435543 - 1.73621300277325*I       Cusp 0      aBDcDcb
+>>> next(spec).length # doctest: +NUMERIC9
+0.90986906036840 + 3.03574280072295*I
+>>> next(spec).length # doctest: +NUMERIC9
+0.98258854739348 - 2.33353878259198*I
+>>> next(spec).length # doctest: +NUMERIC9
+1.00610499287709 - 3.02617893116978*I
+>>> next(spec).length # doctest: +NUMERIC9
+1.13551437663552 - 2.12918861416187*I
+>>> next(spec).length # doctest: +NUMERIC9
+1.63203771292969 + 2.30009520293758*I
+
+Examples with +SKIP from length_spectrum_alt
+
+>>> M = Manifold("m202(3,4)(3,4)")
+>>> spec = M.length_spectrum_alt(count = 3)
+>>> len(spec)
+4
+>>> spec[0].length # doctest: +NUMERIC9
+0.14820741547094 - 1.76955170166922*I
+>>> spec[1].length # doctest: +NUMERIC9
+0.14820741547097 - 1.76955170166923*I
+>>> spec[2].length # doctest: +NUMERIC9
+0.79356651781096 + 2.65902431489655*I
+>>> spec[3].length # doctest: +NUMERIC9
+0.79356651781096 + 2.65902431489655*I
+
+Verified:
+
+sage: spec = M.length_spectrum_alt(count = 3, verified = True, bits_prec = 110)
+sage: len(spec)
+4
+sage: spec[0].length # doctest: +NUMERIC9
+0.14820741547094772? - 1.76955170166923543?*I
+sage: spec[1].length # doctest: +NUMERIC9
+0.14820741547094772? - 1.76955170166923543?*I
+sage: spec[2].length # doctest: +NUMERIC9
+0.79356651781095741? + 2.65902431489655135?*I
+sage: spec[3].length # doctest: +NUMERIC9
+0.79356651781095741? + 2.65902431489655135?*I
+
+>>> M = Manifold("m202(3,4)(0,0)")
+>>> M.length_spectrum_alt(max_len = 1.1) # doctest: +NUMERIC9
+[Length                                      Core curve  Word
+ 0.14742465268512 - 1.78287093565202*I       Cusp 0      aabcDabcB,
+ 0.81161414965958 + 2.72911699294426*I       -           b,
+ 0.84163270359334 + 2.61245944742151*I       -           aB,
+ 0.93461379591349 + 2.70060614107722*I       -           a]
+
+sage: M.length_spectrum_alt(max_len = 1.1, verified=True, bits_prec=130) # doctest: +NORMALIZE_WHITESPACE
+[Length                                      Core curve  Word
+ 0.14742465268515... - 1.78287093565201...*I Cusp 0      aabcDabcB,
+ 0.81161414965958... + 2.72911699294425...*I -           b,
+ 0.84163270359334... + 2.61245944742151...*I -           aB,
+ 0.93461379591349... + 2.70060614107721...*I -           a]
+
+
+"""
+
+if not __doc__:
+    raise Exception("doc string with tests was not recognized.")