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

snappy/exterior_to_link/put_in_S3.py

@@ -0,0 +1,156 @@
+import itertools
+from ..snap.t3mlite.simplex import *
+from .rational_linear_algebra import QQ, Vector3, Vector4, Matrix
+from .barycentric_geometry import (BarycentricPoint,
+                                  BarycentricArc,
+                                  InfinitesimalArc)
+from .mcomplex_with_link import McomplexWithLink
+
+
+def transfer_arcs(M, N):  # from M to N.
+    M.rebuild()
+    M.connect_arcs()
+    N.rebuild()
+    iso = M.isomorphisms_to(N, orientation_preserving=True, at_most_one=True)[0]
+    arcs_M = [M[i].arcs for i in range(len(M))]
+    arcs_N = [N[i].arcs for i in range(len(N))]
+    for t_M in M:
+        t_N = iso[t_M.Index][0]
+        for arc in t_M.arcs:
+            x0 = arc.start
+            x1 = arc.end
+            map = iso[t_M.Index][1]
+            y0 = x0.permute(map)
+            y1 = x1.permute(map)
+            a = BarycentricArc(y0, y1)
+            t_N.arcs += [a]
+    N.rebuild()
+    N.connect_arcs()
+    return N
+
+
+def example10():
+    """
+    >>> E = example10()
+    >>> len(E.link_components())
+    1
+    """
+    def BP(*vec):
+        v = Vector4(vec)
+        v = v/sum(v)
+        return BarycentricPoint(*v)
+
+    base_tri = [([0,1,0,1], [(2,1,0,3), (0,3,2,1), (2,1,0,3), (0,1,3,2)]),
+                ([1,1,0,0], [(1,0,2,3), (1,0,2,3), (0,1,3,2), (0,3,2,1)])]
+
+    M = McomplexWithLink(base_tri)
+    T0, T1 = M.Tetrahedra
+    a0 = BP(17, 18, 0, 19)
+    a1 = BP(0, 18, 17, 19)
+    a2 = BP(10, 30, 11, 60)
+    a3 = BP(30, 0, 11, 10)
+    b0 = BP(14, 0, 15, 16)
+    b1 = BP(0, 14, 15, 16)
+    b3 = BP(30, 10, 11, 0)
+    c0 = BP(5, 1, 2, 0)
+    c1 = BP(4, 1, 10, 0)
+    c2 = BP(20, 50, 71, 0)
+    d0 = BP(5, 1, 0, 2)
+    d1 = BP(4, 1, 0, 10)
+    d2 = BP(20, 50, 0, 71)
+    BA = BarycentricArc
+    for p in [a0, a1, a2, a3, b0, b1, b3, c0, c1, c2, d0, d1, d2]:
+        p.round(1117, force=True)
+    T0.arcs = [BA(a1, c0), BA(c1, a0), BA(c2, a2), BA(a2, a3)]
+    T1.arcs = [BA(b3, d1), BA(d0, b0), BA(b1, d2)]
+    M._build_link()
+    return M
+
+
+x0, x1, y0, y1, z0 = 1, 3, 2, 2, 2
+A0 = Vector3([0, y0, z0])
+A1 = Vector3([0, -y0, z0])
+A2 = Vector3([-y0, 0, 2*z0])
+A3 = Vector3([y0, 0, 2*z0])
+F0 = Vector3([0, 0, 3*z0])
+
+B0 = Vector3([0, -y0, -z0])
+B1 = Vector3([y0, 0, -2*z0])
+B2 = Vector3([0, y0, -z0])
+B3 = Vector3([-y0, 0, -2*z0])
+F1 = Vector3([0, 0, -3*z0])
+
+U0 = Vector3([x0, 0, 0])
+U1 = Vector3([x1, -y1, 0])
+U2 = Vector3([x1, y1,0])
+
+V0 = Vector3([-x0, 0, 0])
+V1 = Vector3([-x1, y1, 0])
+V2 = Vector3([-x1, -y1,0])
+
+tet0_map = Matrix([A0, A1, A2, A3]).transpose()
+tet1_map = Matrix([B0, B1, B2, B3]).transpose()
+
+fin_top_map = Matrix([A2, A3, F0]).transpose()
+fin_bottom_map = Matrix([B1, B3, F1]).transpose()
+fin_right_map = Matrix([U0, U1, U2]).transpose()
+fin_left_map = Matrix([V0, V1, V2]).transpose()
+
+
+def embed_link_in_S3(M):
+    """
+    >>> K = example10()
+    >>> components = embed_link_in_S3(K)
+    >>> len(components), len(components[0])
+    (1, 19)
+    """
+    target = 'cMcabbgdv'
+    assert M.isosig() == target
+    K = transfer_arcs(M, McomplexWithLink(target))
+    ans = []
+    for arcs in K.link_components():
+        component = []
+        for arc in arcs:
+            v = arc.start.vector
+            if isinstance(arc, InfinitesimalArc):
+                if arc.start_tet.Index == 0:
+                    component.append(tet0_map * v)
+                    if v[0] == 0:
+                        face_cor = Vector3([v[2], v[3], v[1]])
+                        component.append(fin_top_map * face_cor)
+                        assert arc.end_tet.Index == 0
+                    elif v[1] == 0:
+                        face_cor = Vector3([v[2], v[3], v[0]])
+                        component.append(fin_top_map * face_cor)
+                        assert arc.end_tet.Index == 0
+                    elif v[2] == 0:
+                        face_cor = Vector3([v[0], v[1], v[3]])
+                        component.append(fin_right_map * face_cor)
+                    elif v[3] == 0:
+                        face_cor = Vector3([v[0], v[2], v[1]])
+                        component.append(fin_left_map * face_cor)
+                else:
+                    component.append(tet1_map * v)
+                    if v[0] == 0:
+                        face_cor = Vector3([v[1], v[3], v[2]])
+                        component.append(fin_bottom_map * face_cor)
+                    elif v[1] == 0:
+                        face_cor = Vector3([v[0], v[2], v[3]])
+                        component.append(fin_left_map * face_cor)
+                    elif v[2] == 0:
+                        face_cor = Vector3([v[1], v[3], v[0]])
+                        component.append(fin_bottom_map * face_cor)
+                    elif v[3] == 0:
+                        face_cor = Vector3([v[0], v[1], v[2]])
+                        component.append(fin_right_map * face_cor)
+
+            else:
+                tet_map = tet0_map if arc.tet.Index == 0 else tet1_map
+                component.append(tet_map * v)
+        ans.append(component)
+    return ans
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

snappy/exterior_to_link/rational_linear_algebra.py

@@ -0,0 +1,123 @@
+"""
+Inside Sage, we use Sage's rational linear algebra, otherwise we use
+PARI via cypari. In fact, PARI is slightly faster, but the version
+that comes with Sage leaks memory::
+
+  https://github.com/sagemath/cypari2/issues/112
+
+See::
+
+  rational_linear_algebra_wrapped.py
+
+for exactly the methods used.
+"""
+
+use_pari_even_inside_sage = False
+
+from .. import sage_helper
+
+if sage_helper._within_sage and not use_pari_even_inside_sage:
+    from ..sage_helper import QQ, RR, vector, matrix, VectorSpace
+
+    def rational_sqrt(x):
+        """
+        Given a nonnegative rational x, return a rational r which is close to
+        sqrt(x) with the guarantee that r <= sqrt(x).
+        """
+        if x < 0:
+            raise ValueError('negative input')
+        r = QQ(RR(x).sqrt())
+        return r if r**2 <= x else x/r
+
+    QQ2 = VectorSpace(QQ, 2)
+    QQ3 = VectorSpace(QQ, 3)
+    QQ4 = VectorSpace(QQ, 4)
+
+    def Vector2(entries):
+        ans = QQ2(entries)
+        ans.set_immutable()
+        assert len(ans) == 2
+        return ans
+
+    def Vector3(entries):
+        ans = QQ3(entries)
+        ans.set_immutable()
+        assert len(ans) == 3
+        return ans
+
+    def Vector4(entries):
+        ans = QQ4(entries)
+        ans.set_immutable()
+        assert len(ans) == 4
+        return ans
+
+    def Matrix(entries):
+        return matrix(QQ, entries)
+
+else:
+    from ..snap.t3mlite import linalg
+    QQ = linalg.pari
+
+    def rational_sqrt(x):
+        """
+        Given a nonnegative rational x, return a rational r which is close to
+        sqrt(x) with the guarantee that r <= sqrt(x).
+        """
+        if x < 0:
+            raise ValueError('negative input')
+        elif x == 0:
+            return QQ(0)
+        for e in [50, 100, 500, 1000, 10000]:
+            r = QQ(x).sqrt().bestappr(2**e)
+            if r != 0:
+                break
+        assert r > 0
+        if r**2 > x:
+            r = x/r
+        assert r**2 <= x
+        return r
+
+    class Vector(linalg.Vector):
+        """
+        An immutable vector in QQ^n.
+
+        >>> a = Vector(3, [1, 2, 3])
+        >>> b = Vector(3, [-1, 2, -2])
+        >>> a + b
+        [0, 4, 1]
+        >>> 2*(a + b) == Vector(3, [0, 8, 2])
+        True
+        >>> a/2
+        [1/2, 1, 3/2]
+        """
+        def __hash__(self):
+            return hash(repr(self))
+
+        def __setitem__(self, i, value):
+            raise ValueError('Vector is immutable')
+
+    def Vector2(*args, **kwargs):
+        ans = Vector(*args, **kwargs)
+        assert len(ans) == 2
+        return ans
+
+    def Vector3(*args, **kwargs):
+        ans = Vector(*args, **kwargs)
+        assert len(ans) == 3
+        return ans
+
+    def Vector4(*args, **kwargs):
+        ans = Vector(*args, **kwargs)
+        assert len(ans) == 4
+        return ans
+
+    class Matrix(linalg.Matrix):
+        """
+        A matrix over QQ.
+        """
+        _vector_class = Vector
+
+
+if __name__ == '__main__':
+    import doctest
+    print(doctest.testmod())

snappy/exterior_to_link/rational_linear_algebra_wrapped.py

@@ -0,0 +1,135 @@
+"""
+Currently, a thin wrapper on Sage's vector/matrix class. The point of
+doing this is to determine exactly what bits of Sage are actually
+using.
+
+Notes:
+
+1. Only use Vectors of size 2, 3, and 4.
+
+2. Matrices of shapes::
+
+     [(2, 2), (3, 3), (4, 4), (2, 3), (3, 2), (3, 4), (4, 3)]
+
+   Likely some shapes only appear on the way to taking the transpose.
+
+This file is not currently used by SnapPy, but is kept for possible
+future reference.
+"""
+from ..sage_helper import QQ, vector, matrix, VectorSpace
+
+
+class Vector:
+    """
+    An immutable vector in QQ^n.
+
+    >>> a = Vector([1, 2, 3])
+    >>> b = Vector([-1, 2, -2])
+    >>> a + b
+    (0, 4, 1)
+    >>> 2*(a + b) == Vector([0, 8, 2])
+    True
+    """
+    def __init__(self, entries=None):
+        self.vector = vector(QQ, entries)
+        self.vector.set_immutable()
+        # assert 2 <= len(self) <= 4
+
+    def __hash__(self):
+        return hash(self.vector)
+
+    def __repr__(self):
+        return repr(self.vector)
+
+    def __add__(self, other):
+        return Vector(self.vector + other.vector)
+
+    def __sub__(self, other):
+        return Vector(self.vector - other.vector)
+
+    def __eq__(self, other):
+        if isinstance(other, int) and other == 0:
+            return self.vector == 0
+        return self.vector == other.vector
+
+    def __ne__(self, other):
+        return self.vector != other.vector
+
+    def __rmul__(self, scalar):
+        return Vector(scalar*self.vector)
+
+    def __mul__(self, other):
+        if isinstance(other, Vector):
+            return self.vector * other.vector
+
+    def __len__(self):
+        return len(self.vector)
+
+    def __neg__(self):
+        return Vector(-self.vector)
+
+    def __truediv__(self, scalar):
+        return Vector(self.vector/scalar)
+
+    def __getitem__(self, index):
+        if isinstance(index, slice):
+            return Vector(self.vector[index])
+        return self.vector[index]
+
+
+class Vector2(Vector):
+    def __init__(self, entries):
+        assert len(entries) == 2
+        Vector.__init__(self, entries)
+
+
+class Vector3(Vector):
+    def __init__(self, entries):
+        assert len(entries) == 3
+        Vector.__init__(self, entries)
+
+
+class Vector4(Vector):
+    def __init__(self, entries):
+        assert len(entries) == 4
+        Vector.__init__(self, entries)
+
+
+class Matrix:
+    """
+    A matrix over QQ.
+    """
+    def __init__(self, entries=None):
+        self.matrix = matrix(QQ, entries)
+        # shape = (self.matrix.nrows(), self.matrix.ncols())
+        # assert shape in [(2, 2), (3, 3), (4, 4), (2, 3), (3, 2), (3, 4), (4, 3)]
+
+    def det(self):
+        return self.matrix.det()
+
+    def transpose(self):
+        return Matrix(self.matrix.transpose())
+
+    def inverse(self):
+        return Matrix(self.matrix.inverse())
+
+    def solve_right(self, b):
+        return Vector(self.matrix.solve_right(b.vector))
+
+    def __mul__(self, other):
+        if isinstance(other, Vector):
+            return Vector(self.matrix*other.vector)
+        # Used only in link_projection.random_transform, I think.
+        if isinstance(other, Matrix):
+            return Matrix(self.matrix*other.matrix)
+
+    def rows(self):
+        return [Vector(row) for row in self.matrix.rows()]
+
+    def __getitem__(self, index):
+        return Vector(self.matrix[index])
+
+
+if __name__ == '__main__':
+    import doctest
+    print(doctest.testmod())

snappy/exterior_to_link/simplify_to_base_tri.py

@@ -0,0 +1,114 @@
+"""
+
+Simplifying triangulations of the 3-sphere to the base triangulation.
+
+"""
+
+import json
+import os
+from .mcomplex_with_memory import McomplexWithMemory
+from .mcomplex_with_expansion import McomplexWithExpansion
+from .mcomplex_with_link import (link_triangulation,
+                                 McomplexWithLink,
+                                 add_arcs_to_standard_solid_tori)
+
+json_file = os.path.join(os.path.dirname(__file__), 'geodesic_map.json')
+geodesic_map = json.load(open(json_file))
+
+
+def geodesic_moves(mcomplex):
+    """
+    For a triangulation of S^3 with 5 or fewer tetrahedra, give 2 -> 3
+    and 3 -> 2 moves that turn it into the base triangulation along
+    the geodesic path in the Pachner graph.
+
+    >>> data = [([0,3,1,0], [(3,1,2,0),(0,2,1,3),(1,3,0,2),(3,1,2,0)]),
+    ...          ([0,2,2,2], [(2,0,3,1),(3,0,1,2),(0,1,3,2),(3,2,0,1)]),
+    ...          ([1,1,4,1], [(1,2,3,0),(2,3,1,0),(3,2,0,1),(0,1,3,2)]),
+    ...          ([4,4,0,4], [(3,1,2,0),(0,1,3,2),(0,2,1,3),(0,1,3,2)]),
+    ...          ([2,3,3,3], [(2,3,1,0),(0,1,3,2),(0,1,3,2),(3,1,2,0)])]
+    >>> M = McomplexWithMemory(data)
+    >>> transferred = geodesic_moves(M)
+    >>> M.perform_moves(transferred)
+    >>> M.isosig()
+    'cMcabbgdv'
+    """
+
+    A = McomplexWithMemory(mcomplex._triangulation_data())
+    isosig = A.isosig()
+    B = McomplexWithMemory(isosig)
+    new_moves = []
+
+    for move in geodesic_map[isosig]:
+        iso = B.isomorphisms_to(A, at_most_one=True)[0]
+        move_type, B_edge, B_face, B_tet_idx = move
+        A_tet, perm = iso[B_tet_idx]
+        assert A_tet in A.Tetrahedra
+        new_move = (move_type, perm.image(B_edge), perm.image(B_face), A_tet.Index)
+        new_moves.append(new_move)
+        A.perform_moves([new_move])
+        B.perform_moves([move])
+
+    return new_moves
+
+
+def simplifications(manifold, max_tries=5):
+    tries = 0
+    rand_steps = 0
+    tris_that_simplify = []
+    jiggle = 100
+
+    while tries < max_tries:
+        if tries > 0 and len(tris_that_simplify) == 0:
+            if rand_steps == 0:
+                rand_steps = 1
+            elif rand_steps < 100:
+                rand_steps = 2*rand_steps
+        tries += 1
+        T = link_triangulation(manifold, add_arcs=False,
+                               jiggle_limit=jiggle,
+                               randomize=rand_steps,
+                               easy_simplify=True,
+                               simplify=False)
+        if T is None:
+            continue
+        M = McomplexWithLink(T._triangulation_data())
+
+        add_arcs_to_standard_solid_tori(M, manifold.num_cusps())
+
+        counter = 0
+        while len(T) > 5 and counter <= 20:
+            counter += 1
+            T.simplify()
+            T.easy_simplify()
+            if len(T) <= 5:
+                unexpanded = len(T.move_memory) - T.moves_added_by_expansion
+                T.rebuild()
+                unexpanded += len(geodesic_map[T.isosig()])
+                tris_that_simplify.append((M, T.move_memory, unexpanded))
+                break
+
+    tris_that_simplify.sort(key=lambda s:len(s[1]))
+    return tris_that_simplify
+
+
+def good_simplification(manifold, max_tries=5):
+    """
+    >>> M = Manifold('K4a1')
+    >>> ans = good_simplification(M, max_tries=1)
+    >>> len(ans[1]) > ans[2]
+    True
+    """
+    tris_with_moves = simplifications(manifold, max_tries)
+    if tris_with_moves:
+        M, moves, unexpanded = tris_with_moves[0]
+        T = McomplexWithExpansion(M._triangulation_data())
+        T.perform_moves(moves, tet_stop_num=5)
+        final_moves = geodesic_moves(T)
+        T.perform_moves(final_moves)
+        return M, T.move_memory, unexpanded
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()