snappy 3.2__cp310-cp310-macosx_10_12_x86_64.whl

snappy/verify/test.py

@@ -0,0 +1,78 @@
+from snappy import testing
+import snappy
+
+from snappy import verify
+
+def generate_test_with_shapes_engine(module, engine):
+    def result(verbose, print_info=True):
+        globs = {'Manifold' : snappy.Manifold}
+
+        original = verify.CertifiedShapesEngine
+        verify.CertifiedShapesEngine = engine
+
+        r = testing.doctest_modules([ module ],
+                                    verbose=verbose,
+                                    print_info=print_info,
+                                    extraglobs=globs)
+
+        verify.CertifiedShapesEngine = original
+
+        return r
+
+    result.__name__ = module.__name__ + '__with__' + engine.__name__
+
+    return result
+
+modules = [
+    generate_test_with_shapes_engine(
+        verify.krawczyk_shapes_engine,
+        verify.KrawczykShapesEngine),
+    generate_test_with_shapes_engine(
+        verify.interval_newton_shapes_engine,
+        verify.IntervalNewtonShapesEngine),
+    generate_test_with_shapes_engine(
+        verify.hyperbolicity,
+        verify.KrawczykShapesEngine),
+    generate_test_with_shapes_engine(
+        verify.hyperbolicity,
+        verify.IntervalNewtonShapesEngine),
+    verify.canonical,
+    verify.interval_tree,
+    verify.volume,
+    verify.upper_halfspace.ideal_point,
+    verify.upper_halfspace.finite_point,
+    verify.upper_halfspace.extended_matrix,
+    verify.maximal_cusp_area_matrix,
+    verify.maximal_cusp_area_matrix.cusp_tiling_engine,
+    verify.maximal_cusp_area_matrix.cusp_translate_engine,
+    verify.square_extensions,
+    verify.real_algebra
+]
+
+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__ = verify.__name__
+
+def check_certified_intervals():
+    for n in ['m009', 'm015', 't02333', 't02333(1,2)',
+              'm129(2,3)', 'm129(2,3)(3,4)']:
+        M = Manifold(n)
+        high_prec = M.tetrahedra_shapes('rect', bits_prec=1000)
+
+        intervals = M.tetrahedra_shapes('rect', bits_prec=100,
+                                        intervals=True)
+
+        for z, interval in zip(high_prec, intervals):
+            if not abs(interval.center() - z) < 1e-10:
+                raise Exception
+
+            if z not in interval:
+                raise Exception
+
+if __name__ == '__main__':
+    testing.run_doctests_as_main(run_doctests)

snappy/verify/upper_halfspace/__init__.py

@@ -0,0 +1,9 @@
+"""
+Classes and functions for the upper half space model **H**\\ :sup:`3` of hyperbolic space
+using interval arithmetics.
+
+"""
+
+from .ideal_point import *
+from .finite_point import *
+from .extended_matrix import *

snappy/verify/upper_halfspace/extended_matrix.py

@@ -0,0 +1,100 @@
+from ...sage_helper import _within_sage
+
+if _within_sage:
+    from ...sage_helper import sqrt
+
+__all__ = ['ExtendedMatrix']
+
+
+class ExtendedMatrix():
+    """
+    An extended PGL(2,C)-matrix. It consists of a SageMath ``Matrix`` with
+    coefficients in SageMath's ``ComplexIntervalField`` together with a flag
+    to indicate whether it acts in an orientation reversing way (i.e.,
+    conjugates before letting the matrix act as Moebius transformation).
+
+    Multiply two extended matrix::
+
+        sage: from sage.all import matrix, CIF
+        sage: m = ExtendedMatrix(matrix([[CIF(2), CIF(0,2)],[CIF(1,2), CIF(3,4)]]))
+        sage: m2 = ExtendedMatrix(matrix.identity(CIF, 2), isOrientationReversing = True)
+        sage: m * m2
+        ExtendedMatrix([      2     2*I]
+        [1 + 2*I 3 + 4*I], isOrientationReversing = True)
+
+    """
+
+    def __init__(self, matrix, isOrientationReversing=False):
+        if isinstance(matrix, ExtendedMatrix):
+            self.matrix = matrix.matrix
+            self.isOrientationReversing = (
+                matrix.isOrientationReversing ^ isOrientationReversing)
+        else:
+            self.matrix = matrix
+            self.isOrientationReversing = isOrientationReversing
+
+    @staticmethod
+    def _mul_impl(a, b):
+        if not isinstance(a, ExtendedMatrix):
+            a = ExtendedMatrix(a)
+        if not isinstance(b, ExtendedMatrix):
+            b = ExtendedMatrix(b)
+
+        if a.isOrientationReversing:
+            b_matrix = b.matrix.conjugate()
+        else:
+            b_matrix = b.matrix
+
+        return ExtendedMatrix(
+            a.matrix * b_matrix,
+            a.isOrientationReversing ^ b.isOrientationReversing)
+
+    def __mul__(self, other):
+        return ExtendedMatrix._mul_impl(self, other)
+
+    def __rmul__(self, other):
+        return ExtendedMatrix._mul_impl(other, self)
+
+    def __repr__(self):
+        if self.isOrientationReversing:
+            return 'ExtendedMatrix(%r, isOrientationReversing = True)' % self.matrix
+        else:
+            return 'ExtendedMatrix(%r)' % self.matrix
+
+    @staticmethod
+    def extract_matrix_for_orientation_preserving(m):
+        """
+        Always returns a SageMath matrix whether given a SageMath matrix or
+        an :class:`ExtendedMatrix`.
+
+        Raises exception if given an orientation reversing extended matrix.
+        """
+
+        if isinstance(m, ExtendedMatrix):
+            if m.isOrientationReversing:
+                raise ValueError("Expected orientation preserving "
+                                 "ExtendedMatrix.")
+            return m.matrix
+        return m
+
+    @staticmethod
+    def get_orientation_sign(m):
+        """
+        Returns +1 or -1 depending on whether the given (extended) matrix
+        acts orientation preserving or reversing.
+        """
+
+        if isinstance(m, ExtendedMatrix):
+            if m.isOrientationReversing:
+                return -1
+        return +1
+
+    @staticmethod
+    def get_trace_in_PSL(m):
+        """
+        Given an (extended) matrix acting in an orientation preserving way,
+        computes the trace after normalizing the matrix to be in SL(2,C).
+        """
+
+        m = ExtendedMatrix.extract_matrix_for_orientation_preserving(m)
+        return (m[0,0] + m[1,1]) / sqrt(m.det())

snappy/verify/upper_halfspace/finite_point.py

@@ -0,0 +1,283 @@
+from ...sage_helper import _within_sage
+
+if _within_sage:
+    import sage
+    from ...sage_helper import matrix, sqrt, is_RealIntervalFieldElement, Infinity
+
+from .extended_matrix import ExtendedMatrix
+
+__all__ = ['FinitePoint']
+
+
+class FinitePoint():
+    """
+    A point in the upper half space model represented by the quaternion
+    z + t * j with t > 0. For example, the point (1 + 2 * i) + 3 * j is::
+
+        sage: from sage.all import *
+        sage: FinitePoint(CIF(1,2),RIF(3))
+        FinitePoint(1 + 2*I, 3)
+
+    The first argument to :class:`FinitePoint` is z and an element in
+    SageMath's ``ComplexIntervalField``. The second argument is t and in
+    ``RealIntervalField``.
+    """
+
+    def __init__(self, z, t):
+        self.z = z
+        self.t = t
+
+    def key_interval(self):
+        """
+        Returns an element in ``RealIntervalField`` which can be used as key
+        for an interval tree to implement a mapping from :class:`FinitePoint`::
+
+            sage: from sage.all import *
+            sage: FinitePoint(CIF(1,2),RIF(3)).key_interval() # doctest: +NUMERIC12
+            36.8919985104477?
+
+        """
+
+        RIF = self.z.real().parent()
+        pi = RIF.pi()
+        return (self.z.real() +
+                self.z.imag() * pi +
+                self.t * pi * pi)
+
+    def translate_PSL(self, m):
+        """
+        Let an extended PSL(2,C)-matrix or a PSL(2,C)-matrix act on the finite
+        point.
+        The matrix m should be an :class:`ExtendedMatrix` or a SageMath ``Matrix``
+        with coefficients in SageMath's ``ComplexIntervalField`` and have
+        determinant 1::
+
+            sage: from sage.all import *
+            sage: pt = FinitePoint(CIF(1,2),RIF(3))
+            sage: m = matrix([[CIF(0.5), CIF(2.4, 2)],[CIF(0.0), CIF(2.0)]])
+            sage: pt.translate_PSL(m) # doctest: +NUMERIC12
+            FinitePoint(1.4500000000000000? + 1.5000000000000000?*I, 0.75000000000000000?)
+            sage: m = ExtendedMatrix(m, isOrientationReversing = True)
+            sage: pt.translate_PSL(m) # doctest: +NUMERIC12
+            FinitePoint(1.4500000000000000? + 0.50000000000000000?*I, 0.75000000000000000?)
+
+        """
+
+        return self._translate(m, normalize_matrix=False)
+
+    def translate_PGL(self, m):
+        """
+        Let an extended PGL(2,C)-matrix or a PGL(2,C)-matrix act on the finite
+        point.
+        The matrix m should be an :class:`ExtendedMatrix` or a SageMath
+        ``Matrix`` with coefficients in SageMath's ``ComplexIntervalField``::
+
+            sage: from sage.all import *
+            sage: pt = FinitePoint(CIF(1,2),RIF(3))
+            sage: m = matrix([[CIF(0.25), CIF(1.2, 1)],[CIF(0.0), CIF(1.0)]])
+            sage: pt.translate_PGL(m) # doctest: +NUMERIC12
+            FinitePoint(1.4500000000000000? + 1.5000000000000000?*I, 0.75000000000000000?)
+
+        """
+
+        return self._translate(m, normalize_matrix=True)
+
+    def _translate(self, m, normalize_matrix):
+
+        # Poincare extension, see, e.g.,
+        # Katsuhiko Matsuzaki and Masahiko Taniguchi:
+        # "Hyperbolic Manifolds and Kleinian Groups"
+        #
+        # The matrix [[a,b],[c,d]] acts on z + t * j as
+        #
+        # (a*(z+t*j) + b) * (c*(z+t*j) + d)^(-1) =
+        #
+        #                 _ _   _        _    2
+        #    (a*z + b) * (c*z + d) + a * c * t  + t * j
+        #  ----------------------------------------------
+        #                                 2
+        #            | c * (z + t*j) + d |
+
+        if isinstance(m, ExtendedMatrix):
+            mat = m.matrix
+            if m.isOrientationReversing:
+                z = self.z.conjugate()
+            else:
+                z = self.z
+        else:
+            mat = m
+            z = self.z
+
+        if normalize_matrix:
+            mat = mat / sqrt(mat.det())
+
+        # a * z + b
+        az_b = mat[0,0] * z + mat[0,1]
+        # c * z + d
+        cz_d = mat[1,0] * z + mat[1,1]
+
+        # Denominator
+        # | c * (z + t * j) + d |^2 =
+        # | c * z + d + c * t * j | ^2 =
+        # | c * z + d| ^ 2 + |c * t|^2
+        denom = _abs_sqr(cz_d) + _abs_sqr(mat[1,0] * self.t)
+
+        num = ( az_b * cz_d.conjugate() +
+                  mat[0,0] * mat[1,0].conjugate() * self.t ** 2)
+
+        return FinitePoint(num / denom, self.t / denom)
+
+    def cosh_dist(self, other):
+        """
+        Returns cosh of the distance of this finite point to another
+        finite point::
+
+            sage: from sage.all import *
+            sage: a = FinitePoint(CIF(1,2),RIF(3))
+            sage: b = FinitePoint(CIF(4,5),RIF(6))
+            sage: a.cosh_dist(b) # doctest: +NUMERIC12
+            1.7500000000000000?
+
+        """
+
+        # The distance between two points in the upper half plane model is
+        # given by
+        #                                                  2          2
+        #                                           (x2-x1)  + (y2-y1)
+        #   dist( (x1,y1), (x2, y2) = arcosh(  1 + ---------------------  )
+        #                                               2 * y1 * y2
+        #
+        # according to
+        # http://en.wikipedia.org/wiki/Poincar%C3%A9_half-plane_model .
+        #
+        # For the upper half space model, y1 and y2 are the two heights
+        # t and (x2-x1)^2 is the square of the absolute value of the difference
+        # of the two z.
+
+        r = 1 + (((self.t - other.t) ** 2 + _abs_sqr(self.z - other.z)) /
+                 (2 * self.t * other.t))
+
+        # Due to rounding-errors, we can get a value that is just slightly
+        # smaller than 1, even though we know that this is mathematically
+        # impossible. This can cause taking arccosh later to fail.
+        #
+        # To avoid this failure, make sure the result is at least 1 - or
+        # in the interval case, ensure that the interval does not contain
+        # values below 1.
+        #
+        RIF = r.parent()
+        if _within_sage:
+            if is_RealIntervalFieldElement(r):
+                return r.intersection(RIF(1, Infinity))
+        if r < 1.0:
+            return RIF(1.0)
+        return r
+
+    def dist(self, other):
+        """
+        Returns the distance of this finite point to another finite point::
+
+            sage: from sage.all import *
+            sage: a = FinitePoint(CIF(1,2),RIF(3))
+            sage: b = FinitePoint(CIF(4,5),RIF(6))
+            sage: a.dist(b) # doctest: +NUMERIC12
+            1.158810360429947?
+
+        """
+        # Note: SageMath 8.1 doesn't compute arccosh correctly for a
+        # complex interval, but at least it does so for a real interval.
+        return self.cosh_dist(other).arccosh()
+
+    def __repr__(self):
+        return 'FinitePoint(%r, %r)' % (self.z, self.t)
+
+
+###############################################################################
+# Various helpers
+
+def _abs_sqr(z):
+    return z.real() ** 2 + z.imag() ** 2
+
+################################################################################
+#
+# TESTING
+
+
+class _FinitePointTester():
+    """
+    A test rig for FinitePoint.
+
+    Run the test rig::
+
+        sage: _FinitePointTester().run_tests()
+
+    """
+
+    def matrix1(self):
+        from sage.all import RIF, CIF, matrix
+        return matrix(
+            [[CIF(RIF(1.3), RIF(-0.4)), CIF(RIF(5.6), RIF(2.3))],
+             [CIF(RIF(-0.3), RIF(0.1)), CIF(1)]])
+
+    def extended_matrix1(self, isOrientationReversing):
+        return ExtendedMatrix(self.matrix1(), isOrientationReversing)
+
+    def matrix2(self):
+        from sage.all import RIF, CIF, matrix
+        return matrix(
+            [[CIF(RIF(0.3), RIF(-1.4)), CIF(RIF(3.6), RIF(6.3))],
+             [CIF(RIF(-0.3), RIF(1.1)), CIF(1)]])
+
+    def extended_matrix2(self, isOrientationReversing):
+        return ExtendedMatrix(self.matrix2(), isOrientationReversing)
+
+    def images_have_same_distance(self, m):
+        from sage.rings.real_mpfi import RealIntervalFieldElement
+
+        from sage.all import RIF, CIF
+        a = FinitePoint(CIF(RIF(3.5),RIF(-3.0)), RIF(8.5))
+        b = FinitePoint(CIF(RIF(4.5),RIF(-4.5)), RIF(9.6))
+
+        d_before = a.dist(b)
+
+        a = a.translate_PGL(m)
+        b = b.translate_PGL(m)
+
+        d_after = a.dist(b)
+
+        if not isinstance(d_before, RealIntervalFieldElement):
+            raise Exception("Expected distance to be RIF")
+        if not isinstance(d_after, RealIntervalFieldElement):
+            raise Exception("Expected distance to be RIF")
+
+        if not abs(d_before - d_after) < RIF(1e-12):
+            raise Exception("Distance changed %r %r" % (d_before, d_after))
+
+    def matrix_multiplication_works(self, matrices):
+        from sage.all import RIF, CIF, prod
+
+        a = FinitePoint(CIF(RIF(3.5),RIF(-3.0)), RIF(8.5))
+
+        a0 = a.translate_PGL(prod(matrices))
+        for m in matrices[::-1]:
+            a = a.translate_PGL(m)
+
+        if not a.dist(a0) < RIF(1e-6):
+            raise Exception("Distance %r" % a.dist(a0))
+
+    def run_tests(self):
+
+        m1o = self.extended_matrix1(False)
+        m1r = self.extended_matrix1(True)
+        m2o = self.extended_matrix2(False)
+        m2r = self.extended_matrix2(True)
+
+        self.images_have_same_distance(m1o)
+        self.images_have_same_distance(m1o * m1o)
+        self.images_have_same_distance(m1o * m1o * m1o)
+        self.images_have_same_distance(m1o * m1o * m1o * m1o)
+        self.images_have_same_distance(m1o * m2o)
+
+        self.matrix_multiplication_works([m1o, m1o, m2r, m1o])
+        self.matrix_multiplication_works([m1o, m1r, m2r, m1o])
+        self.matrix_multiplication_works([m2r, m1o, m2r, m1o])