snappy 3.3__cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

snappy/verify/test.py

@@ -0,0 +1,72 @@
+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.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/volume.py

@@ -0,0 +1,128 @@
+from ..sage_helper import sage_method, _within_sage
+from ..number import Number
+
+if _within_sage:
+    from sage.rings.complex_interval_field import ComplexIntervalField
+    try:
+        import sage.rings.abc
+
+        def is_ComplexIntervalField(z):
+            return isinstance(z, sage.rings.abc.ComplexIntervalField)
+    except ImportError:
+        from sage.rings.complex_interval_field import is_ComplexIntervalField
+    from sage.rings.complex_arb import ComplexBallField
+    from sage.rings.real_mpfi import RealIntervalField
+
+__all__ = ['compute_volume']
+
+from . import hyperbolicity
+
+# Sage's handling of pari has a bug when it comes to precision and the dilog.
+# It computes the dilogarithm only to low precision even though higher precision
+# is demanded, for example:
+# >>> ComplexField(600)(1/2+sqrt(-3)/2).dilog()
+# 0.274155677808037739629767534643711712760705268010497093200683593750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + 1.01494160640965362502224633965050127985270614620051806369642217221943674062982124585777232717020979180233553051948547363281250000000000000000000000000000000000000000000000000000000*I
+#
+# Also see: https://groups.google.com/forum/#!topic/sage-devel/NmBp4usk2_Q
+#
+# We work around this by converting to snappy.Number where a work-around for this was
+# implemented.
+
+
+def _unprotected_volume_from_shape(z):
+    """
+    Computes the Bloch-Wigner dilogarithm for z assuming z is of a type that
+    properly supports polylog.
+    """
+
+    # Note: For this to be correct the branch cut policy applied to
+    # (1-z).arg() and dilog must be the same. Do not cast to a different
+    # z or 1-z to a different number types when applying (1-z).arg() and
+    # z.polylog(2).
+    #
+    # What is meant by branch cut policy?
+    # For values -1 + epsilon * I, z.arg() will be close to +pi.
+    # For values -1 - epsilon * I, z.arg() will be close to -pi.
+    # For exactly -1, the convention is to return +pi.
+    #
+    # But what about -1 + small interval close to 0?
+    # Different number types give different results.
+    # ComplexIntervalField, for example, decided whether to return an interval
+    # close to +pi or close to -pi based on whether the interval contains 0 -
+    # in other words, it is picking a lift.
+    # It is picking this lift deterministically, but it might pick a different
+    # lift if the precision is changed.
+    #
+    # Since we just flip the sign of the imaginary part when computing 1-z,
+    # the interval for the imaginary part of z contains zero if and only if
+    # the imaginary part of 1-z contains zero, so the same branch cut is chosen
+    # for (1-z).arg() and z.polylog(2).
+
+    return (1-z).arg() * z.abs().log() + z.polylog(2).imag()
+
+
+def _volume_from_shape(z):
+    """
+    Computes the Bloch-Wigner dilogarithm for z which gives the volume of a
+    tetrahedron of the given shape.
+    """
+
+    if _within_sage:
+        CIF = z.parent()
+        if is_ComplexIntervalField(CIF):
+            # A different bug in sage:
+            # Depending on the sage version, an element in a
+            # ComplexIntervalField wouldn't support dilog/polylog, or, even
+            # worse, would convert the element to ComplexField first!!!
+            #
+            # Thus, we convert to ComplexBallField here since the arblib
+            # supports a verified interval polylog (albeit giving an interval
+            # that seems to be 300 times larger than necessary).
+
+            CBF = ComplexBallField(CIF.precision())
+            RIF = RealIntervalField(CIF.precision())
+
+            return RIF(_unprotected_volume_from_shape(CBF(z)))
+        else:
+            z = Number(z)
+
+    # Use implementation in number.py that overcomes the cypari bug that you
+    # have to explicitly give a precision to dilog, otherwise you lose
+    # precision.
+    return z.volume()
+
+
+def compute_volume(manifold, verified, bits_prec=None):
+    """
+    Computes the volume of the given manifold. If verified is used,
+    the hyperbolicity is checked rigorously and the volume is given as
+    verified interval.
+
+    >>> M = Manifold('m004')
+    >>> vol = M.volume(bits_prec=100)
+    >>> vol # doctest: +ELLIPSIS
+    2.029883212819307250042405108...
+
+    sage: ver_vol = M.volume(verified=True)
+    sage: vol in ver_vol
+    True
+    sage: 2.02988321283 in ver_vol
+    False
+    """
+    # Compute tetrahedra shapes to arbitrary precision.  If requested,
+    # verify that this is indeed a solution to the polynomial gluing
+    # equations.
+    shape_intervals = manifold.tetrahedra_shapes(
+        'rect', bits_prec=bits_prec, intervals=verified)
+
+    if verified:
+        # If requested, check it is a valid hyperbolic structure
+        hyperbolicity.check_logarithmic_gluing_equations_and_positively_oriented_tets(
+            manifold, shape_intervals)
+
+    # Sum up the volumes of all the tetrahedra
+    volume = sum([ _volume_from_shape(shape_interval)
+                   for shape_interval in shape_intervals])
+    if isinstance(volume, Number):
+        volume = manifold._number_(volume)
+    return volume

snappy/version.py

@@ -0,0 +1,2 @@
+version = '3.3'
+release_date = 'January 2026'

snappy-3.3.dist-info/METADATA

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: snappy
+Version: 3.3
+Summary: Studying the topology and geometry of 3-manifolds, with a focus on hyperbolic structures.
+Home-page: http://snappy.computop.org
+Author: Marc Culler and Nathan M. Dunfield
+Author-email: culler@uic.edu, nathan@dunfield.info
+License: GPLv2+
+Keywords: 3-manifolds,topology,hyperbolic geometry
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: C
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Cython
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+Requires-Dist: FXrays>=1.3
+Requires-Dist: plink>=2.4.7
+Requires-Dist: spherogram>=2.4
+Requires-Dist: snappy_manifolds>=1.4
+Requires-Dist: low_index>=1.2.1
+Requires-Dist: tkinter-gl>=1.0
+Requires-Dist: decorator
+Requires-Dist: packaging
+Requires-Dist: pypng
+Requires-Dist: PyX
+Requires-Dist: pickleshare
+Requires-Dist: cypari>=2.3
+Requires-Dist: ipython>=5.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+SnapPy
+======
+
+SnapPy is a package for studying the topology and geometry of
+3-manifolds, with a focus on hyperbolic structures.  It is based on
+the SnapPea kernel written by `Jeff Weeks
+<http://www.geometrygames.org>`_.  
+
+Complete documentation is available on the web including the `main
+page <http://snappy.computop.org>`_ and an `installation guide
+<http://snappy.computop.org/installing.html>`_.  You can also browse
+the `source code <https://github.com/3-manifolds/SnapPy>`_.
+