snappy 3.3__cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

snappy/margulis/mu_from_neighborhood_pair.py

@@ -0,0 +1,175 @@
+from .neighborhood import Neighborhood
+from .geodesic_neighborhood import GeodesicNeighborhood
+from .cusp_neighborhood_neighborhood import CuspNeighborhoodNeighborhood
+
+from ..math_basics import correct_min, correct_max, upper
+
+def mu_from_neighborhood_pair(
+        neighborhood1 : Neighborhood,
+        neighborhood2 : Neighborhood,
+        object_distance, verified : bool):
+
+    is_cusp1 = isinstance(neighborhood1, CuspNeighborhoodNeighborhood)
+    is_cusp2 = isinstance(neighborhood2, CuspNeighborhoodNeighborhood)
+    if is_cusp1 and is_cusp2:
+        return mu_from_cusp_neighborhood_pair(
+            neighborhood1, neighborhood2, object_distance)
+
+    if neighborhood1.index == neighborhood2.index:
+        return neighborhood1.epsilon_from_radius(object_distance / 2)
+
+    return mu_from_neighborhood_pair_generic(
+        neighborhood1, neighborhood2, object_distance, verified=verified)
+
+def _my_max(values):
+    n = len(values)
+    if n == 0:
+        raise RuntimeError("No values to take max")
+    if n == 1:
+        return values[0]
+    return correct_max(values)
+
+def mu_from_neighborhood_pair_generic(
+        neighborhood1, neighborhood2, object_distance, verified):
+
+    lower_bound_epsilon = _my_max([
+        neighborhood.geodesic_info.length.real()
+        for neighborhood in [ neighborhood1, neighborhood2 ]
+        if isinstance(neighborhood, GeodesicNeighborhood) ])
+
+    lower_bound_radius1 = neighborhood1.radius_from_epsilon(lower_bound_epsilon)
+    lower_bound_radius2 = neighborhood2.radius_from_epsilon(lower_bound_epsilon)
+    lower_bound_total_radius = lower_bound_radius1 + lower_bound_radius2
+
+    if lower_bound_total_radius > object_distance:
+        return lower_bound_epsilon
+
+    if lower_bound_total_radius < object_distance:
+        return mu_from_neighborhood_pair_implicit(
+            neighborhood1, neighborhood2,
+            object_distance,
+            lower_bound_epsilon,
+            verified)
+
+    if verified:
+        upper_bound_epsilon1 = (
+            neighborhood1.epsilon_from_radius(object_distance))
+        upper_bound_epsilon2 = (
+            neighborhood2.epsilon_from_radius(object_distance))
+        upper_bound_epsilon = correct_min([
+            upper_bound_epsilon1, upper_bound_epsilon2])
+        return lower_bound_epsilon.union(upper_bound_epsilon)
+    else:
+        return lower_bound_epsilon
+
+def mu_from_neighborhood_pair_implicit(
+        neighborhood1, neighborhood2,
+        object_distance,
+        lower_bound_mu,
+        verified):
+
+    initial_mu = correct_max([neighborhood1.epsilon,neighborhood2.epsilon])
+
+    mu = mu_from_neighborhood_pair_newton(
+        neighborhood1, neighborhood2,
+        object_distance,
+        initial_mu,
+        lower_bound_mu,
+        verified=verified)
+
+    if verified:
+        return mu_from_neighborhood_pair_newton_interval(
+            neighborhood1, neighborhood2,
+            object_distance,
+            mu)
+    else:
+        return mu
+
+_max_iterations_newton = 500
+
+def mu_from_neighborhood_pair_newton(
+        neighborhood1, neighborhood2,
+        object_distance,
+        initial_mu,
+        lower_bound_mu,
+        verified):
+
+    RF = initial_mu.parent()
+    mu = initial_mu
+
+    pos_diff = None
+    neg_diff = None
+
+    abs_diff = None
+    for i in range(_max_iterations_newton):
+        radius1, d1 = neighborhood1.radius_and_derivative_from_epsilon(mu)
+        radius2, d2 = neighborhood2.radius_and_derivative_from_epsilon(mu)
+
+        radius = radius1 + radius2
+        d = d1 + d2
+
+        diff = object_distance - radius
+
+        if diff >= 0:
+            if pos_diff is not None:
+                if not diff < pos_diff:
+                    return mu
+            pos_diff = diff
+        else:
+            if neg_diff is not None:
+                if not -diff < -neg_diff:
+                    return mu
+            neg_diff = diff
+
+        new_mu = mu + diff / d
+        safe_mu = (mu - lower_bound_mu) / 8 + lower_bound_mu
+        mu = correct_max([new_mu, safe_mu])
+
+        if verified:
+            mu = RF(mu.center())
+
+    raise RuntimeError("Newton method did not converge")
+
+def mu_from_neighborhood_pair_newton_interval(
+        neighborhood1 : Neighborhood,
+        neighborhood2 : Neighborhood,
+        object_distance,
+        mu_sample):
+
+    radius1 = neighborhood1.radius_from_epsilon(mu_sample)
+    radius2 = neighborhood2.radius_from_epsilon(mu_sample)
+    radius = radius1 + radius2
+
+    diff = object_distance - radius
+
+    mu_interval = mu_sample
+
+    for i in range(50):
+        d1 = neighborhood1.radius_derivative_from_epsilon(mu_interval)
+        d2 = neighborhood2.radius_derivative_from_epsilon(mu_interval)
+        d = d1 + d2
+
+        new_mu_interval = mu_sample + diff / d
+
+        if new_mu_interval in mu_interval:
+            return new_mu_interval
+
+        mu_interval = mu_interval.union(new_mu_interval)
+
+    raise RuntimeError(
+        "Interval Newton method did not converge for neighborhood pair %r %r, object_distance = %r, mu_sample = %r, mu_interval = %r" % (
+            neighborhood1, neighborhood2, object_distance, mu_sample, mu_interval))
+
+
+def mu_from_cusp_neighborhood_pair(
+        neighborhood1 : CuspNeighborhoodNeighborhood,
+        neighborhood2 : CuspNeighborhoodNeighborhood,
+        object_distance):
+    # Radius1 + radius2 = minimum
+    # log(h / _factor1) + log(h / _factor2) = minimum
+    # log(h^2 / (_factor1 * _factor2)) = minimum
+    # h^2 = exp(minimum) / (_factor1 * _factor2)
+
+    len_prod = neighborhood1.euclidean_length * neighborhood2.euclidean_length
+    h = (object_distance.exp() * len_prod).sqrt()
+    return 2 * (h/2).arcsinh()

snappy/margulis/neighborhood.py

@@ -0,0 +1,29 @@
+from ..snap.t3mlite import Mcomplex
+from ..tiling.tile import Tile
+from ..math_basics import lower
+
+from typing import Iterable, Optional
+
+class Neighborhood:
+    def __init__(self, mcomplex : Mcomplex, index : int):
+        self.index = index
+        self.tet_to_tiles : list[Tile] = [ [] for tet in mcomplex.Tetrahedra ]
+        self.radius = -mcomplex.infinity
+        self.tile_stream : Optional[Iterable[Tile]] = None
+        self.added = False
+
+    def get_next_tile(self) -> Tile:
+        if self.tile_stream is None:
+            self.tile_stream = self._get_tile_stream()
+        return next(self.tile_stream)
+
+    def add_next_tile(self, next_tile : Tile) -> None:
+        tet_index = next_tile.lifted_tetrahedron.tet.Index
+        self.tet_to_tiles[tet_index].append(next_tile)
+
+    def update_radius_and_epsilon(self, next_tile : Tile) -> None:
+        self.radius = next_tile.lower_bound_distance
+        self.epsilon = self.epsilon_from_radius(self.radius)
+
+    def __lt__(self, other):
+        return lower(self.epsilon) < lower(other.epsilon)

snappy/margulis/test.py

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

snappy/math_basics.py

@@ -0,0 +1,187 @@
+from .sage_helper import _within_sage
+from .exceptions import InsufficientPrecisionError
+
+from functools import reduce
+import operator
+
+__all__ = ['prod',
+           'xgcd',
+           'is_RealIntervalFieldElement',
+           'is_ComplexIntervalFieldElement'
+           'is_Interval',
+           'correct_min',
+           'correct_max',
+           'lower',
+           'upper']
+
+def is_Interval(x):
+    """
+    Returns True is x is either a real or complex interval as constructed
+    with RealIntervalField or ComplexIntervalField, respectively.
+    """
+    return is_RealIntervalFieldElement(x) or is_ComplexIntervalFieldElement(x)
+
+if _within_sage:
+    from .sage_helper import prod, xgcd
+
+    from sage.rings.real_mpfi import RealIntervalFieldElement
+    from sage.rings.complex_interval import ComplexIntervalFieldElement
+
+    def is_RealIntervalFieldElement(x):
+        return isinstance(x, RealIntervalFieldElement)
+
+    def is_ComplexIntervalFieldElement(x):
+        return isinstance(x, ComplexIntervalFieldElement)
+
+else:
+
+    def prod(L, initial=None):
+        """
+        Product of all elements in L.
+        If L is empty returns initial (if given) or 1.
+        """
+        if initial is not None:
+            return reduce(operator.mul, L, initial)
+        if L:
+            return reduce(operator.mul, L)
+        return 1
+
+    def xgcd(a, b):
+        r"""
+        Returns a triple ``(g,s,t)`` such that `g = s\cdot a+t\cdot b = \gcd(a,b)`.
+
+        >>> xgcd(56, 44)
+        (4, 4, -5)
+        >>> xgcd(5, 7)
+        (1, 3, -2)
+        >>> xgcd(-5, -7)
+        (1, -3, 2)
+        >>> xgcd(5, -7)
+        (1, 3, 2)
+        >>> xgcd(-5, 7)
+        (1, -3, -2)
+        """
+
+        old_r, r = a, b
+        old_s, s = 1, 0
+        old_t, t = 0, 1
+
+        while r != 0:
+            q = old_r // r
+            old_r, r = r, old_r - q * r
+            old_s, s = s, old_s - q * s
+            old_t, t = t, old_t - q * t
+
+        if old_r > 0:
+            return old_r, old_s, old_t
+        return -old_r, -old_s, -old_t
+
+    def is_RealIntervalFieldElement(x):
+        """
+        is_RealIntervalFieldElement returns whether x is a real
+        interval (constructed with RealIntervalField(precision)(value)).
+        """
+
+        # We do not support interval arithmetic outside of SnapPy,
+        # so always return False.
+        return False
+
+    def is_ComplexIntervalFieldElement(x):
+        """
+        is_ComplexIntervalFieldElement returns whether x is a complex
+        interval (constructed with ComplexIntervalField(precision)(value)).
+        """
+
+        # We do not support interval arithmetic outside of SnapPy,
+        # so always return False.
+        return False
+    
+def correct_min(l):
+    """
+    A version of min that works correctly even when l is a list of
+    real intervals.
+
+    This is needed because python's min returns the wrong result
+    for intervals, for example:
+
+        sage: from sage.all import RIF
+        sage: min(RIF(4,5), RIF(3,6)).endpoints()
+        (4.00000000000000, 5.00000000000000)
+
+    when the correct is answer is [3,5].
+
+    The reason is that python's min(x, y) returns either x or y
+    depending on whether y < x. The correct implementation returns
+    the smallest lower and upper bound across all intervals,
+    respectively.
+    """
+    are_intervals = [is_RealIntervalFieldElement(x) for x in l]
+    if any(are_intervals):
+        if not all(are_intervals):
+            raise TypeError(
+                "Trying to compute min of array where some elements are "
+                "intervals and others are not.")
+        # Work-around ticket https://trac.sagemath.org/ticket/33514
+        # That is: SageMath's min/max happily ignores NaNs.
+        #
+        # >>> a = RIF(1)
+        # >>> b = RIF('NaN')
+        # >>> a.min(b)
+        # 1
+        #
+        for x in l:
+            if x.is_NaN():
+                raise ValueError(
+                    "Trying to compute min of array containing NaN interval.")
+        return reduce(lambda x, y: x.min(y), l)
+    else:
+        for x in l:
+            if not x == x:
+                raise ValueError(
+                    "Trying to compute min of array containing NaN.")
+        return min(l)
+
+
+def correct_max(l):
+    """
+    Analogous to correct_min.
+    """
+    are_intervals = [is_RealIntervalFieldElement(x) for x in l]
+    if any(are_intervals):
+        if not all(are_intervals):
+            raise TypeError(
+                "Trying to compute max of array where some elements are "
+                "intervals and others are not.")
+        # Work-around ticket https://trac.sagemath.org/ticket/33514
+        # See above example.
+        for x in l:
+            if x.is_NaN():
+                raise ValueError(
+                    "Trying to compute max of array containing NaN interval.")
+        return reduce(lambda x, y: x.max(y), l)
+    else:
+        for x in l:
+            if not x == x:
+                raise ValueError(
+                    "Trying to compute max of array containing NaN.")
+        return max(l)
+
+def lower(x):
+    if is_RealIntervalFieldElement(x):
+        if x.is_NaN():
+            raise InsufficientPrecisionError(
+                "A NaN was encountered during a verified computation. "
+                "Increasing the precision will probably fix this.")
+        return x.lower()
+    else:
+        return x
+
+def upper(x):
+    if is_RealIntervalFieldElement(x):
+        if x.is_NaN():
+            raise InsufficientPrecisionError(
+                "A NaN was encountered during a verified computation. "
+                "Increasing the precision will probably fix this.")
+        return x.upper()
+    else:
+        return x