snappy 3.1.1__cp39-cp39-macosx_11_0_arm64.whl → 3.2__cp39-cp39-macosx_11_0_arm64.whl

snappy/decorated_isosig.py

@@ -14,8 +14,6 @@ space, the permutation may be omitted when it is equal to the identity
 permutation; this is indicated by the fact that the length of the
 decoration is 4n rather than 5n.
 
-Currently, only oriented manifolds are supported.
-
 A simple valid decorated isosig for a two-cusped manifold is::
 
     eLPkbdcddhgggb_abBaaBBaaB
@@ -36,18 +34,60 @@ isosig, decorator = di.split('_')
 
 Note: An isosig is an invariant of a triangulation of an *unoriented*
 manifold.  For an amphicheiral manifold M, it can happen that
-Manifold(M.triangulation_isosig()) has the opposite orientation from M
-itself.  The decoration implicitly embeds the preferred orientation of
+Manifold(M.triangulation_isosig(decorated=False)) has the opposite
+orientation from M itself.
+The decoration implicitly embeds the preferred orientation of
 M in the sign of the determinant of the change-of-basis matrices.
 
 Note: If the triangulation has combinatorial symmetries, there can be
 multiple change-of-basis matrices that yield combinatorially
 isomorphic pairs (triangulation, peripheral curves).  In such cases,
 the decoration is the lexicographically first one.
+
+Caveat: We pick the decoration with the lexicographically smallest
+encoding with the following consequence: If we have more 26 cusps, the
+lexicographically smallest permutation might not have the smallest encoding
+and thus might not be the one picked.
+
+Caveat: We drop the trivial permutation from the encoding. Pairs (a,b) of string
+come with the lexicographic ordering. We also obtain a (partial) ordering by
+ordering by a + b. These two orderings are not the same.
+In particular, there is a combinatorial isomorphism from
+Triangulation('L6n1') to
+Triangulation(Triangulation('L6n1').triangulation_isosig(decorated = False))
+that acts on the cusp by the identity perm and, thus, we would expect it to
+be preferred. However,
+Triangulation("L6n1(0,0)(0,0)(0,0)").triangulation_isosig() results in
+'gLMzQbcdefffaelaaai_acbBaabCbbabbBC' which does not use the identity perm.
+
+Caveat: There are de-facto two canonical choices of peripheral curves.
+When calling
+>>> T = Triangulation('ovLMvvPQQQccddlmnijklmnmnlgvfamtvfblhaumx'),
+the SnapPea kernel picks peripheral curves and then orients the manifold
+(see data_to_triangulation in kernel_code/kernel/triangulation.c)
+>>> T.set_peripheral_curves('combinatorial')
+is now calling the same SnapPea kernel code to pick peripheral curve but
+on the oriented manifold. This can result in different peripheral curves.
+
+Note that the encoding and decoding needs to use the same of the two
+canonical choices of peripheral curves.
+
+For the decoding, there is a difference based on whether the isosig is
+decorated because set_peripheral_from_decoration calls
+manifold.set_peripheral_curves('combinatorial').
+
+We need to account for that in the encoding: we need to use
+set_peripheral_curves('combinatorial') on the "target" triangulation if
+we anticipate a decoration. And if we called
+set_peripheral_curves('combinatorial'), we need to make sure we have a
+decoration (see force_decoration).
 """
+
 import re
 import string
 
+from .matrix import make_vector
+
 # Used between the base isosig and the decorated version.
 separator = '_'
 
@@ -58,7 +98,7 @@ separator_pat = '[%s]{1}' % separator
 base64_opt_pat = r'([a-zA-Z0-9\+\-]*)'
 isosig_pattern = re.compile(base64_pat + separator_pat + base64_opt_pat + '$')
 
-# We store lists of integers as base64 strings.
+# We store lists of integers as (non-RFC4648) base64 strings.
 
 base64_letters = string.ascii_letters + '0123456789+-'
 base64_lower = string.ascii_lowercase + '01234+'
@@ -66,7 +106,7 @@ base64_upper = string.ascii_uppercase + '56789-'
 in_one = string.ascii_lowercase[:16] + string.ascii_lowercase[1:16].upper()
 
 int_to_letter = dict(enumerate(base64_letters))
-letter_to_int = dict((a, i) for i, a in enumerate(base64_letters))
+letter_to_int = {a: i for i, a in enumerate(base64_letters)}
 
 
 def encode_nonnegative_int(x):
@@ -138,9 +178,9 @@ def decode_integer_list(encoded):
             ans.append(sign*decode_nonnegative_int(current))
     return ans
 
+###############################################################################
 # Some helper functions
 
-
 def det(A):
     return A[0][0]*A[1][1] - A[0][1]*A[1][0]
 
@@ -156,146 +196,253 @@ def as_two_by_two_matrices(L):
     assert len(L) % 4 == 0
     return [[(L[i], L[i+1]), (L[i+2], L[i+3])] for i in range(0, len(L), 4)]
 
+def first_non_zero_entry_in_column(matrix, col):
+    e = matrix[0, col] 
+    if e != 0:
+        return e
+    return matrix[1, col]
 
 def sgn_column(matrix, col):
     """
     Returns +1 or -1 depending on the sign of the first non-zero entry
     in the column of the given matrix.
     """
-    first_non_zero_entry = (
-        matrix[0, col] if matrix[0, col] != 0 else matrix[1, col])
-    return +1 if first_non_zero_entry > 0 else -1
-
+    if first_non_zero_entry_in_column(matrix, col) > 0:
+        return +1
+    else:
+        return -1
 
-def determine_flips(matrices, orientable):
+def apply_peripheral_curve_flips(
+        matrix, slope, manifold_orientable, isomorphism_orientation):
     """
-    Returns pairs [(l,m)] for each given matrix. Multiplying the columns of
-    each matrix with the respective pair brings the matrix in "canonical" form.
+    Flips peripheral curves (as encoded by matrix) to bring them into
+    canonical form and updates slope accordingly.
     """
 
-    if orientable:
-        # Determine whether the given matrices are reversing the orientation of
-        # the entire manifold
-        det_sign = (  matrices[0][0,0] * matrices[0][1,1]
-                      - matrices[0][0,1] * matrices[0][1,0])
+    # Determine whether to flip meridian
+    f0 = sgn_column(matrix, 0)
 
+    # Determine whether to flip longitude
+    if manifold_orientable:
         # We conform the matrix such that the first non-zero entry in the
         # first column and the determinant are always positive
-        return [ (sgn_column(matrix, 0), sgn_column(matrix, 0) * det_sign)
-                 for matrix in matrices ]
+        f1 = f0 * isomorphism_orientation
     else:
         # We conform the matrix such that the first non-zero entry in each
         # column is always positive
-        return [ (sgn_column(matrix, 0), sgn_column(matrix, 1))
-                 for matrix in matrices ]
+        f1 = sgn_column(matrix, 1)
+
+    flips = [ f0, f1 ]
 
+    for col, flip in enumerate(flips):
+        for row in range(2):
+            matrix[row,col] *= flip
+        slope[col] *= flip
 
-def pack_matrices_applying_flips(matrices, flips):
+def pack_matrices(matrices):
     """
     Multiplies the columns of each matrix by the entries in flips and
     packs all the matrices into one array, column-major.
     """
-    result = []
 
-    for matrix, flip in zip(matrices, flips):
-        for col in range(2):
-            for row in range(2):
-                result.append(matrix[row,col] * flip[col])
-
-    return result
+    return  [ matrix[row,col]
+              for matrix in matrices
+              for col in range(2)
+              for row in range(2) ]
 
 
 def supress_minus_zero(x):
-    return 0 if x == 0 else x
+    if x == 0:
+        return 0
+    else:
+        return x
 
-# main two functions
 
+def is_trivial_perm(perm):
+    return all(i == p for i, p in enumerate(perm))
 
-def decorated_isosig(manifold, triangulation_class,
-                     ignore_cusp_ordering=False,
-                     ignore_curve_orientations=False,
-                     ignore_orientation=True):
 
-    isosig = manifold.triangulation_isosig(
-        decorated=False,
-        ignore_orientation=ignore_orientation)
-
-    # Do not decorate if no cusps
-    if manifold.num_cusps() == 0:
-        return isosig
+def key_prefer_pos(x):
+    """
+    Intended for key argument to min.
 
-    N = triangulation_class(isosig, remove_finite_vertices=False)
-    N.set_peripheral_curves('combinatorial')
+    Prefers positive and then absolute value.
+    """
+    
+    if x >= 0:
+        return (0,  x)
+    else:
+        return (1, -x)
 
-    # in Python3 range is an iterator
-    trivial_perm = list(range(manifold.num_cusps()))
+def key_slope(slope):
+    """
+    Intended for key argument to min.
 
-    min_encoded = None
-    min_perm = None
-    min_flips = None
+    Prefers positive and small denominator.
+    """
 
-    # Try all combinatorial isomorphisms
-    for tri_iso in manifold.isomorphisms_to(N):
+    slope_m, slope_l = slope
+    return (key_prefer_pos(slope_l), key_prefer_pos(slope_m))
 
-        # Do not consider orientation-reversing isomorphisms if
-        # ignore_orientation isn't specified.
-        if ( manifold.is_orientable() and
-             not ignore_orientation and
-             det(tri_iso.cusp_maps()[0]) < 0):
-            continue
+def key_decoration_info(info):
+    encoded, slopes = info
+    return [encoded, [key_slope(slope) for slope in slopes]]
 
-        # Permutation of cusps
-        perm = inverse_perm(tri_iso.cusp_images())
+def normalized_slope(slope):
+    """
+    Returns slope or -slope preferring positive and small denominator.
 
-        if ignore_cusp_ordering:
-            # If we do not include the permutation in the encoding,
-            # we need to apply it to the matrices
-            matrices = [ tri_iso.cusp_maps()[i] for i in perm ]
-        else:
-            matrices = tri_iso.cusp_maps()
+    Equivalent to min([slope, -slope], key=key_slope)
+    """
 
+    slope_m, slope_l = slope
+    if slope_l < 0:
+        return -slope
+    if slope_l > 0:
+        return slope
+    if slope_m < 0:
+        return -slope
+    return slope
+
+def candidate_decoration_info(
+        isomorphism,
+        slopes,
+        manifold_orientable,
+        ignore_cusp_ordering,
+        ignore_curves,
+        ignore_curve_orientations,
+        ignore_filling_orientations,
+        ignore_orientation):
+
+    matrices = isomorphism.cusp_maps()
+    isomorphism_orientation = matrices[0].det()
+
+    # Do not consider orientation-reversing isomorphisms if
+    # ignore_orientation isn't specified.
+    if manifold_orientable and not ignore_orientation:
+        if isomorphism_orientation < 0:
+            return None
+
+    # Make a copy as vectors so that we can modify in place and
+    # apply matrices.
+    # Outside of SnapPy, SimpleVector is not making a copy of the
+    # tuple and we need a list to modify things in place.
+    slopes = [ make_vector([slope_m, slope_l])
+               for slope_m, slope_l in slopes ]
+
+    # Permutation of cusps
+    perm = inverse_perm(isomorphism.cusp_images())
+
+    if ignore_cusp_ordering:
+        # If we do not include the permutation in the encoding,
+        # we need to apply it to the matrices
+        matrices = [ matrices[i] for i in perm ]
+        slopes = [ slopes[i] for i in perm ]
+
+    if ignore_curves:
+        slopes = [ matrix * slope
+                   for matrix, slope in zip(matrices, slopes) ]
+    else:
         if ignore_curve_orientations:
-            # Determine the multipliers for the columns of the matrices
-            # to bring them into canonical form if so desired
-            flips = determine_flips(matrices, manifold.is_orientable())
-        else:
-            flips = [ (1,1) for matrix in matrices ]
-
+            for matrix, slope in zip(matrices, slopes):
+                apply_peripheral_curve_flips(
+                    matrix, slope, manifold_orientable, isomorphism_orientation)
+
+    encoded = ''
+
+    if not ignore_cusp_ordering:
+        #
+        # Force decoration to fix a very subtle bug!
+        #
+        # Recall that we call N.set_peripheral_curves('combinatorial')
+        # in decorated_isosig below if either ignore_cusp_ordering or
+        # ignore_curves is False.
+        #
+        # On the decoding site, we thus also need to call
+        # manifold.set_peripheral_curves('combinatorial') in those cases.
+        # This happens in set_peripheral_from_decoration and thus only
+        # if the isosig returned here has a decoration, that is "encoded"
+        # is not empty.
+        #
+        # Assume that ignore_cusp_ordering is False and ignore_curves is
+        # True and the permutation happens to be the identity.
+        #
+        # We need to make sure not to have an empty "encoded" in this case.
+        force_decoration = ignore_curves
+        
+        if force_decoration or not is_trivial_perm(perm):
+            # Encode permutation
+            encoded += encode_integer_list(perm)
+
+    if not ignore_curves:
         # Encode the matrices
-        decorations = pack_matrices_applying_flips(matrices, flips)
+        encoded += encode_integer_list(pack_matrices(matrices))
 
-        if perm == trivial_perm or ignore_cusp_ordering:
-            # Only encode matrices
-            encoded = encode_integer_list(decorations)
-        else:
-            # Encode permutation and matrices
-            encoded = encode_integer_list(perm + decorations)
-
-        if min_encoded is None or encoded < min_encoded:
-            # If this is lexicographically smallest, remember it
-            min_encoded = encoded
-            min_perm = perm
-            min_flips = flips
-
-    # Add decoration to isosig
-    ans = isosig + separator + min_encoded
-
-    # Add Dehn-fillings if we have any
-    if False in manifold.cusp_info('complete?'):
-        if ignore_cusp_ordering:
-            # If we do not include the permutation in the encoding,
-            # we need to apply it to the slopes
-            slopes = [ manifold.cusp_info('filling')[i] for i in min_perm ]
-        else:
-            slopes = manifold.cusp_info('filling')
+    if ignore_filling_orientations:
+        slopes = [ normalized_slope(slope)
+                   for slope in slopes ]
 
-        for flip, slope in zip(min_flips, slopes):
-            # Apply the flips to the slopes
-            ans += '(%g,%g)' % (supress_minus_zero(flip[0] * slope[0]),
-                                supress_minus_zero(flip[1] * slope[1]))
+    return encoded, slopes
 
-    return ans
+# main two functions
 
+def decorated_isosig(manifold, triangulation_class,
+                     ignore_cusp_ordering=False,
+                     ignore_curves=False,
+                     ignore_curve_orientations=False,
+                     ignore_filling_orientations=False,
+                     ignore_orientation=True):
+
+    isosig = manifold._undecorated_triangulation_isosig(
+        ignore_orientation=ignore_orientation)
+
+    # Do not decorate if no cusps
+    if manifold.num_cusps() == 0:
+        return isosig
+
+    N = triangulation_class(isosig, remove_finite_vertices=False)
+    if not (ignore_cusp_ordering and ignore_curves):
+        # Note that data_to_triangulation determines the peripheral
+        # curves before orienting the manifold.
+        # Thus, we get different peripheral curves when calling
+        # N.set_peripheral_curves.
+        # For backwards compatibility (see set_peripheral_from_decoration),
+        # we need to keep calling N.set_peripheral_curves here unless there is
+        # no decoration.
+        N.set_peripheral_curves('combinatorial')
+
+    manifold_orientable = manifold.is_orientable()
+    slopes = manifold.cusp_info('filling')
+
+    # Try all combinatorial isomorphisms and pick
+    # lexicographically smallest info.
+    encoded, slopes = min(
+        (info
+         for isomorphism in manifold.isomorphisms_to(N)
+         if (
+             info := candidate_decoration_info(
+                 isomorphism,
+                 slopes,
+                 manifold_orientable=manifold_orientable,
+                 ignore_cusp_ordering=ignore_cusp_ordering,
+                 ignore_curves=ignore_curves,
+                 ignore_curve_orientations=ignore_curve_orientations,
+                 ignore_filling_orientations=ignore_filling_orientations,
+                 ignore_orientation=ignore_orientation)
+            ) is not None),
+        key = key_decoration_info)
+
+    ans = isosig
+
+    if encoded:
+        ans += separator + encoded
+
+    if not all(manifold.cusp_info('complete?')):
+        for slope_m, slope_l in slopes:
+            ans += '(%g,%g)' % (supress_minus_zero(slope_m),
+                                supress_minus_zero(slope_l))
+
+    return ans
 
 def set_peripheral_from_decoration(manifold, decoration):
     """
@@ -305,16 +452,25 @@ def set_peripheral_from_decoration(manifold, decoration):
     dec = decode_integer_list(decoration)
     manifold.set_peripheral_curves('combinatorial')
     n = manifold.num_cusps()
-    if len(dec) == 4 * n:
-        cobs = as_two_by_two_matrices(dec)
-    else:
-        assert len(dec) == 5 * n
-        manifold._reindex_cusps(dec[:n])
-        cobs = as_two_by_two_matrices(dec[n:])
-    if det(cobs[0]) < 0 and manifold.is_orientable():
-        manifold.reverse_orientation()
-        cobs = [[(-a, b), (-c, d)] for [(a, b), (c,d)] in cobs]
-    manifold.set_peripheral_curves(cobs)
+    k = len(dec)
+
+    if k not in [ n, 4 * n, 5 * n]:
+        raise ValueError("Decoration has unexpected length.")
+
+    if k == n or k == 5 * n:
+        if k == n:
+            manifold._reindex_cusps(dec)
+        else:
+            manifold._reindex_cusps(dec[:n])
+    if k == 4 * n or k == 5 * n:
+        if k == 4 * n:
+            cobs = as_two_by_two_matrices(dec)
+        else:
+            cobs = as_two_by_two_matrices(dec[n:])
+        if det(cobs[0]) < 0 and manifold.is_orientable():
+            manifold.reverse_orientation()
+            cobs = [[(-a, b), (-c, d)] for [(a, b), (c,d)] in cobs]
+        manifold.set_peripheral_curves(cobs)
 
 # Testing code
 
@@ -479,9 +635,76 @@ def test_by_dehn_filling():
 
     print("Tested %d randomly Dehn filled manifolds" % count)
 
+def test_slope_transformations():
+    """
+    Tests that slopes are transformed so that the filled
+    manifold is the same.
+    """
 
-if __name__ == '__main__':
+    import snappy
+    M = snappy.ManifoldHP("L14n63023(-5,1)(5,1)(10,1)")
+    oriented_isosig = M.triangulation_isosig(
+        decorated=False, ignore_orientation=False)
+    isosig = M.triangulation_isosig(
+        decorated=False)
+    Mop = M.copy()
+    Mop.reverse_orientation()
+    reverse_oriented_isosig = Mop.triangulation_isosig(
+        decorated=False, ignore_orientation=False)
+
+    if oriented_isosig != 'vLLvvLLMALQQzQQceillmnppqrlmrqtruututiivimllaelaqxrvdoxqltt':
+        raise AssertionError()
+    if isosig != 'vLLvLLPwPQLAMPQcefikkmnplkopqrsttutuuiixvimqlippawidlabavth':
+        raise AssertionError()
+
+    # The canonical orientation (used to compute the unoriented isosig)
+    # is the reverse of the actual orientation:
+    if reverse_oriented_isosig != isosig:
+        raise AssertionError()
+    if oriented_isosig == isosig:
+        raise ValueError()
+
+    isom_sig_pos = M.isometry_signature(ignore_orientation = False)
+    if isom_sig_pos != 'KLALvLwLLwMQLQPAMzMzMPzMPcbbeghnklntpqpqvrswtuvxyzABCDEFEGHIJJhhkofnaocnmrlsiaowxfcsaxhxhxhxhjhhhhs':
+        raise AssertionError()
+    isom_sig_neg = Mop.isometry_signature(ignore_orientation = False)
+    if isom_sig_neg != 'KLAMvMvvAwLvQPPPQMPzMPzMPcbbdegilopoouqtryvuxvwxzzBACDEFEGHIJJhhkhhohahrscaagwxkkgbvwpuxwqxqxwxxxxr':
+        raise AssertionError()
+
+    # It is not just the triangulation that is chiral, the manifold itself is:
+    if isom_sig_pos == isom_sig_neg:
+        raise ValueError()
+
+    # So we expect the oriented isometry signature to flip when neither the isomorphism
+    # signature nor its decoration capture the orientation.
+    for ignore_cusp_ordering in [False, True]:
+        for ignore_curves in [False, True]:
+            for ignore_curve_orientations in [False, True]:
+                for ignore_filling_orientations in [False, True]:
+                    for ignore_orientation in [False, True]:
+                        isosig = M.triangulation_isosig(
+                            ignore_cusp_ordering = ignore_cusp_ordering,
+                            ignore_curves = ignore_curves,
+                            ignore_curve_orientations = ignore_curve_orientations,
+                            ignore_filling_orientations = ignore_filling_orientations,
+                            ignore_orientation = ignore_orientation)
+                        isom_sig = (
+                            snappy.ManifoldHP(isosig)
+                                 .isometry_signature(ignore_orientation = False))
+                        does_ignore_orientation = (
+                            ignore_orientation and
+                            (ignore_curve_orientations or ignore_curves))
+                        expected_isom_sig = (
+                            isom_sig_neg
+                            if does_ignore_orientation
+                            else isom_sig_pos)
+                        if isom_sig != expected_isom_sig:
+                            raise AssertionError()
+    print("Tested slope transformations")
+
+def run_tests():
     test_integer_list_encoder()
     main_test()
     test_link_invariant()
     test_by_dehn_filling()
+    test_slope_transformations()

snappy/dev/extended_ptolemy/complexVolumesClosed.py

@@ -101,16 +101,49 @@ def has_value(v, values):
     return False
 
 if __name__ == '__main__':
-
+    # Use 5_2(1,2) as an example.
     from snappy import ManifoldHP
 
     M = ManifoldHP("5_2")
     M.chern_simons()
     M.dehn_fill((1,2))
 
-    cvol = M.complex_volume() * sage.all.I
-
-    # Because of ordering issues, only correct up to pi^2/2
-    cvols = sum(complex_volumes(M, precision = 300), [])
-
-    print(has_value(cvol, cvols))
+    # Complex volume of geometric representation of 5_2(1,2).
+    # Unverified.
+    geom_cvol = M.complex_volume()
+
+    # This file uses a different convention (simply adding Neumann's
+    # extensions of Roger's dilogarithm to the Abelian cover of C \ {0,1})
+    # from the rest of SnapPy, so convert.
+    geom_cvol = sage.all.I * geom_cvol
+
+    # The complex volumes as verified intervals of the SL(2,C)-representations
+    # detected by the (spun-)triangulation.
+    # Grouped by algebraic component of the extended Ptolemy variety.
+    #
+    # We can only compute it in this file up to multiples of pi^2/2.
+    #
+    # (Note that Neumann's method can compute it up to multiple of pi^2 but
+    # assumes an ordered triangulation. Most census triangulations are not
+    # orderable and would require subdivision).
+    #
+    # The method uses SageMath's giac to compute the rational univariate
+    # representation and evaluates it at the roots of the defining polynomial
+    # using complex intervals.
+    #
+    # It can be accessed from sage (with SnapPy installed) by:
+    # from snappy.dev.extended_ptolemy.complexVolumesClosed import complex_volumes
+    #
+    # Tested with SageMath 9.7 and 10.0.
+    #
+    cvols_by_component = complex_volumes(M, precision = 300)
+
+    print(cvols_by_component)
+
+    # Concatenate the grouped complex volumes to just have a single list.
+    cvols = sum(cvols_by_component, [])
+
+    if not has_value(geom_cvol, cvols):
+        raise RuntimeError(
+            "There is a problem. The complex volume of the geometric "
+            "representation is not included.")

snappy/dev/extended_ptolemy/extended.py

@@ -153,7 +153,7 @@ def simplify_equation(poly):
 def extended_ptolemy_equations(manifold, gen_obs_class=None,
                                nonzero_cond=True, return_full_var_dict = False,
                                notation = 'short'):
-    """
+    r"""
     We assign ptolemy coordinates ['a', 'b', 'c', 'd', 'e', 'f'] to the
     *directed* edges::
 
@@ -165,12 +165,12 @@ def extended_ptolemy_equations(manifold, gen_obs_class=None,
 
              1
             /|\
-          d/ | \e
+         d / | \ e
           /  |  \
          /   |   \
         2----|----3   with back edge from 2 to 3 labelled f.
          \   |   /
-         b\  |a /c
+        b \  |a / c
            \ | /
             \|/
              0