snappy 3.0.3__cp38-cp38-macosx_11_0_arm64.whl → 3.2__cp38-cp38-macosx_11_0_arm64.whl

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

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

snappy/database.py

@@ -11,25 +11,28 @@ the required "snappy_manifolds".  Such a package must provide a
 "get_tables" function that accepts the below "ManifoldTable" as input
 and returns a list of subclasses of "ManifoldTable".
 """
-
-from __future__ import print_function
-from builtins import range
 from .db_utilities import decode_torsion, decode_matrices, db_hash
 from .sage_helper import _within_sage
 from spherogram.codecs import DTcodec
-import sys, sqlite3, re, os, random, importlib, collections
+import sys
+import sqlite3
+import re
+import random
+import importlib
+import collections
 
 if _within_sage:
-    import sage.all
+    from .sage_helper import Integer, RealDoubleElement, RealNumber
+
     def is_int(slice):
-        return isinstance(slice, (sage.all.Integer,int))
+        return isinstance(slice, (Integer, int))
 
     def is_int_or_none(slice):
-        return isinstance(slice, (sage.all.Integer,int, type(None)))
+        return isinstance(slice, (Integer, int, type(None)))
 
     def is_float_or_none(slice):
-        return isinstance(slice, (float, sage.all.RealDoubleElement,
-                                  sage.rings.real_mpfr.RealNumber, type(None)))
+        return isinstance(slice, (float, RealDoubleElement,
+                                  RealNumber, type(None)))
 else:
     def is_int(slice):
         return isinstance(slice, int)
@@ -42,6 +45,7 @@ else:
 
 split_filling_info = re.compile(r'(.*?)((?:\([0-9 .+-]+,[0-9 .+-]+\))*$)')
 
+
 def connect_to_db(db_path):
     """
     Open the given sqlite database, ideally in read-only mode.
@@ -58,6 +62,7 @@ def connect_to_db(db_path):
     else:
         return sqlite3.connect(db_path)
 
+
 def mfld_hash(manifold):
     """
     We cache the hash to speed up searching for one manifold in
@@ -67,7 +72,8 @@ def mfld_hash(manifold):
         manifold._cache['db_hash'] = db_hash(manifold)
     return manifold._cache['db_hash']
 
-class ManifoldTable(object):
+
+class ManifoldTable():
     """
     Iterator for cusped manifolds in an sqlite3 table of manifolds.
 
@@ -92,6 +98,7 @@ class ManifoldTable(object):
                  mfld_hash=mfld_hash, **filter_args):
         self._table = table
         self.mfld_hash = mfld_hash
+        self._db_path = db_path
         self._connection = connect_to_db(db_path)
         self._cursor = self._connection.cursor()
         self._set_schema()
@@ -99,12 +106,12 @@ class ManifoldTable(object):
         self._configure(**filter_args)
         self._get_length()
         self._get_max_volume()
-        self._select = self._select%table
+        self._select = self._select % table
 
     def _set_schema(self):
         cursor, table = self._cursor, self._table
         rows = cursor.execute("pragma table_info('%s')" % table).fetchall()
-        self.schema = dict([(row[1],row[2].lower()) for row in rows])
+        self.schema = {row[1]: row[2].lower() for row in rows}
 
     def _check_schema(self):
         assert (self.schema['name'] == 'text' and
@@ -163,9 +170,9 @@ class ManifoldTable(object):
     def __repr__(self):
         class_name = self.__class__.__name__
         if self._filter == '':
-            return '%s without filters'%class_name
+            return '%s without filters' % class_name
         else:
-            return '%s with filter: %s'%(class_name, self._filter)
+            return '%s with filter: %s' % (class_name, self._filter)
 
     def __call__(self, **kwargs):
         return self.__class__(**kwargs)
@@ -176,7 +183,7 @@ class ManifoldTable(object):
     def __iter__(self):
         query = self._select
         if self._filter:
-            query += ' where %s order by id'%self._filter
+            query += ' where %s order by id' % self._filter
         cursor = self._connection.cursor()
         for row in cursor.execute(query):
             yield self._manifold_factory(row)
@@ -239,11 +246,11 @@ class ManifoldTable(object):
             if len(matches) != 1:
                 raise IndexError('Manifold index is out of bounds')
         elif isinstance(index, str):
-            matches = self.find("name='%s'"%index)
+            matches = self.find("name='%s'" % index)
             if len(matches) != 1:
-                raise KeyError('The manifold %s was not found.'%index)
+                raise KeyError('The manifold %s was not found.' % index)
         else:
-            raise IndexError('%s is not a valid index type for manifolds.'%
+            raise IndexError('%s is not a valid index type for manifolds.' %
                              type(index))
         return matches[0]
 
@@ -261,7 +268,7 @@ class ManifoldTable(object):
         isosig = m.group(1)
         M._from_isosig(isosig)
 
-        fillings = eval( '[' + m.group(2).replace(')(', '),(')+ ']', {})
+        fillings = eval( '[' + m.group(2).replace(')(', '),(') + ']', {})
 
         if fillings:
             M.dehn_fill(fillings)
@@ -283,11 +290,11 @@ class ManifoldTable(object):
         """
         if hasattr(self, '_regex'):
             if self._regex.match(name) is None:
-                raise KeyError('The manifold %s was not found.'%name)
+                raise KeyError('The manifold %s was not found.' % name)
         cursor = self._cursor.execute(self._select + "where name='" + name + "'")
         rows = cursor.fetchall()
         if len(rows) != 1:
-            raise KeyError('The manifold %s was not found.'%name)
+            raise KeyError('The manifold %s was not found.' % name)
         return self._manifold_factory(rows[0], M)
 
     def keys(self):
@@ -320,18 +327,18 @@ class ManifoldTable(object):
         Return all manifolds in the census which have the same hash value.
         """
         vol = mfld.volume()
-        epsilon = vol/1e5
+        epsilon = vol / 1e5
         v_lower, v_upper = vol - epsilon, vol + epsilon
         cusps = mfld.cusp_info('is_complete').count(True)
         H = mfld.homology()
         betti = H.betti_number()
-        torsion = [c for c in H.elementary_divisors() if c!=0]
-        initial_candidates = self.find(
-          "volume between %f and %f and cusps=%d and betti=%d and torsion='%s'"
-          % (v_lower, v_upper, cusps, betti, torsion))
-        if len(initial_candidates) == 0:
+        torsion = [c for c in H.elementary_divisors() if c != 0]
+        txt = "volume between %f and %f and cusps=%d and betti=%d and torsion='%s'"
+        initial_candidates = self.find(txt % (v_lower, v_upper, cusps,
+                                              betti, torsion))
+        if not initial_candidates:
             return []
-        return self.find("hash = '%s'"%self.mfld_hash(mfld))
+        return self.find("hash = '%s'" % self.mfld_hash(mfld))
 
     def identify(self, mfld, extends_to_link=False):
         """
@@ -384,7 +391,7 @@ class ManifoldTable(object):
                 except RuntimeError:
                     pass
 
-        mfld = mflds[0]
+        mfld = Triangulation(mflds[0]) # Drop the hyperbolic structure
         # Check for identical triangulations.
         if (False not in mfld.cusp_info('is_complete')) and not extends_to_link:
             for n in range(100):
@@ -408,9 +415,11 @@ class ManifoldTable(object):
 # The below function is used to add ManifoldTables defined in external
 # packages.
 
+
 this_module = sys.modules[__name__]
 __all_tables__ = collections.OrderedDict()
 
+
 def add_tables_from_package(package_name, must_succeed=True):
     """
     Given a string with the name of an importable Python package that
@@ -423,7 +432,7 @@ def add_tables_from_package(package_name, must_succeed=True):
         package = importlib.import_module(package_name)
     except ImportError:
         if not must_succeed:
-            return dict()
+            return {}
         else:
             raise ImportError('ManifoldTable package %s not found'
                               % package_name)
@@ -438,7 +447,7 @@ def add_tables_from_package(package_name, must_succeed=True):
     # We also store the tables here so that their doctests can be
     # checked.
     if not hasattr(this_module, '__test__'):
-        this_module.__test__ = dict()
+        this_module.__test__ = {}
     for name, table in new_tables.items():
         this_module.__test__[name] = table.__class__
 

snappy/db_utilities.py

@@ -2,14 +2,10 @@ from hashlib import md5
 import array
 import re
 
+
 # Codecs we use.
-try:
-    unichr
-    def encode_torsion(divisors):
-        return ''.join(unichr(x) for x in divisors).encode('utf8')
-except: # Python3
-    def encode_torsion(divisors):
-        return ''.join(chr(x) for x in divisors).encode('utf8')
+def encode_torsion(divisors):
+    return ''.join(chr(x) for x in divisors).encode('utf8')
 
 
 def decode_torsion(utf8):
@@ -21,7 +17,7 @@ def encode_matrices(matrices):
     Convert a list of 2x2 integer matrices into a sequence of bytes.
     """
     # The tricky thing here is converting signed integers to bytes.
-    return bytes(array.array('b', sum(sum(matrices,[]),[])).tostring())
+    return bytes(array.array('b', sum(sum(matrices, []), [])).tostring())
     # NOTE: tostring is deprecated in python3, but for now
     # it does the same thing as tobytes.
 
@@ -35,15 +31,16 @@ def decode_matrices(byteseq):
     return [ [ list(m[n:n+2]), list(m[n+2:n+4]) ]
              for n in range(0, len(m), 4) ]
 
+
 # Some hash functions for manifolds:
 
 def old_basic_hash(mfld, digits=6):
-    return '%%%df'%digits%mfld.volume() + " " + repr(mfld.homology())
+    return '%%%df' % digits % mfld.volume() + " " + repr(mfld.homology())
 
 
 def basic_hash(mfld, digits=6):
     if mfld.solution_type() != 'contains degenerate tetrahedra':
-        volume = '%%%df'%digits%mfld.volume()
+        volume = '%%%df' % digits % mfld.volume()
     else:
         volume = 'degenerate'
     return volume + " " + repr(mfld.homology())
@@ -55,18 +52,20 @@ def cover_type(mfld):
 
 def cover_hash(mfld, degrees):
     return [ repr(sorted(
-        [(cover_type(C), C.homology()) for C in mfld.covers(degree)]
+        [(cover_type(C), C.homology())
+             for C in mfld.covers(degree, method='snappea')]
         )) for degree in degrees ]
 
 
 def old_combined_hash(mfld):
-    hash = str(" &and& ".join( [old_basic_hash(mfld)] + cover_hash(mfld, (2,3)) ))
+    hash = str(" &and& ".join([old_basic_hash(mfld)] +
+                              cover_hash(mfld, (2, 3))))
     return hash.encode('utf8')
 
 
 def combined_hash(mfld):
-    hash = str(" &and& ".join( [basic_hash(mfld)] +
-                               cover_hash(mfld, (2,3)) ))
+    hash = str(" &and& ".join([basic_hash(mfld)] +
+                              cover_hash(mfld, (2, 3))))
     return hash.encode('utf8')