snappy 3.3__cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

snappy/snap/t3mlite/edge.py

@@ -0,0 +1,172 @@
+# $Id: edge.py,v 1.3 2002/09/20 03:52:16 culler Exp $
+#   t3m - software for studying triangulated 3-manifolds
+#   Copyright (C) 2002 Marc Culler, Nathan Dunfield and others
+#
+#   This program is distributed under the terms of the
+#   GNU General Public License, version 2 or later, as published by
+#   the Free Software Foundation.  See the file GPL.txt for details.
+
+from .simplex import *
+from .corner import Corner
+from .arrow import Arrow
+from .perm4 import Perm4
+import sys
+
+# A table used for _add_corner, equivalent to:
+# other_arrow = arrow.copy().opposite()
+# tail, head = other_arrow.tail(), other_arrow.head()
+
+_edge_add_corner_dict = {}
+for edge, face in EdgeFacePairs:
+    other_arrow = Arrow(edge, face, None).opposite()
+    _edge_add_corner_dict[edge, face] = other_arrow.tail(), other_arrow.head()
+
+
+# An edge has an initial and terminal vertex, but these are determined
+# arbitrarily when the 1-skeleton is constructed.
+
+class Edge:
+
+    def __init__(self):
+        self.Index = -1
+        self.Name = ''
+        self.IntOrBdry = ''         # value: '', 'int' or 'bdry'
+        self.Corners = []           # Corners of type "1-simplex in Tetrahedron"
+        self.Vertices = []          # pairs: (initial Vertex, terminal Vertex)
+        self.LeftBdryArrow = None   # Arrows representing the two boundary faces,
+        self.RightBdryArrow = None  # if this is a boundary edge.
+        self._edge_orient_cache = {}
+
+    def __repr__(self):
+        if self.Index > -1:
+            return ('e' + str(self.Index) + self.Name +
+                    ' (' + self.IntOrBdry + ')')
+        else:
+            return '< floating edge' + str(id(self)) + ' >'
+
+    # below added by NMD for more detailed printing
+
+    # returns an arrow rotating around self
+
+    def get_arrow(self):
+        e = self.Corners[0].Subsimplex
+        return Arrow(e, RightFace[e], self.Corners[0].Tetrahedron)
+
+    def info(self, out=sys.stdout):
+        out.write(repr(self) + "\t Edge of valence %d\tEndpoints %s\n"
+                  % (self.valence(), self.Vertices))
+        if self.IntOrBdry == 'bdry':
+            a = self.LeftBdryArrow.copy()
+            a.reverse()
+        else:
+            a = self.get_arrow()
+        s = "\t"
+        for i in range(self.valence()):
+            s = s + repr(a) + "  "
+            a.next()
+            if i > 0 and (i + 1) % 3 == 0 and i != (self.valence()-1):
+                s = s + "\n\t"
+        out.write(s + '\n')
+
+    def valence(self):
+        return len(self.Corners)
+
+# Return 1 if all corners belong to distinct tetrahedra.
+    def distinct(self):
+        for corner in self.Corners:
+            corner.Tetrahedron.Checked = 0
+        for corner in self.Corners:
+            if corner.Tetrahedron.Checked == 1:
+                return 0
+            else:
+                corner.Tetrahedron.Checked = 1
+        return 1
+
+# Return 1 if two sides of a 2-simplex are identified to the edge.
+    def self_adjacent(self):
+        for corner in self.Corners:
+            for one_subsimplex in AdjacentEdges[corner.Subsimplex]:
+                if corner.Tetrahedron.Class[one_subsimplex] is self:
+                    return 1
+        return 0
+
+# Return 1 if two opposite edges of a 3-simplex are identified to
+# the edge.
+    def self_opposite(self):
+        count = 0
+        for corner in self.Corners:
+            if corner.Tetrahedron.Class[comp(corner.Subsimplex)] == self:
+                count = count + 1
+        return count/2
+
+# Remove all references to self from adjoining Tetrahedra and Vertices
+    def erase(self):
+        for corner in self.Corners:
+            corner.Tetrahedron.Class[corner.Subsimplex] = None
+        for vertex in self.Vertices:
+            try:
+                vertex.Edges.remove(self)
+            except:
+                pass
+        self.Index = -1
+
+    # Below added 7/6/99 by NMD.  Given a tetrahedra and a pair of vertices
+    # (a, b) returns the orientation of the edge self with respect to the arrow
+    # (a -> b).  Returns 1 if the orientations agree and -1 if they differ.
+    # raises an exception if the arrow is not on this edge.
+
+    def orientation_with_respect_to(self, tet, a, b):
+        try:
+            return self._edge_orient_cache[(tet, a, b)]
+        except IndexError:
+            raise ValueError("Given corner of tet not on this edge")
+
+    def index(self):
+        return self.Index
+
+    def _first_embedding(self):
+        """
+        For this edge, return an edge embedding similar
+        to regina, that is a pair (tetrahedron, permutation) such that
+        vertex 0 and 1 of the tetrahedron span the edge.
+        """
+
+        corner = self.Corners[0]
+        tet = corner.Tetrahedron
+
+        for perm in Perm4.A4():
+            if corner.Subsimplex == perm.image(E01):
+                # Match orientation of edge given by Vertices
+                if tet.Class[perm.image(V0)] == self.Vertices[0]:
+                    if tet.Class[perm.image(V1)] == self.Vertices[1]:
+                        return (tet, perm)
+
+    def embeddings(self):
+        """
+        Iterator through the embeddings of this edge.
+        An edge embedding is a pair (tetrahedron, permutation) such that
+        vertices of the tetrahedron that are labeled by the images of 0 and 1
+        under the permutation span the edge. The images of 2 and 3 of the edge
+        embeddings are in an orientation compatible way.
+        This is similar to the NEdgeEmbeddings of regina.
+        """
+
+        order = len(self.Corners)
+        tet, perm = self._first_embedding()
+        for i in range(order):
+            yield tet, perm
+            face = perm.image(F2)
+            tet, perm = (
+                tet.Neighbor[face], tet.Gluing[face] * perm * Perm4( (0,1,3,2) ))
+
+    def _add_corner(self, arrow):
+        """
+        Used by Mcomplex.build_edge_classes
+        """
+        self.Corners.append(Corner(arrow.Tetrahedron, arrow.Edge))
+        # Next line equivalent to:
+        # other_arrow = arrow.copy().opposite()
+        # tail, head = other_arrow.tail(), other_arrow.head()
+        tail, head = _edge_add_corner_dict[arrow.Edge, arrow.Face]
+        self._edge_orient_cache[arrow.Tetrahedron, tail, head] = 1
+        self._edge_orient_cache[arrow.Tetrahedron, head, tail] = -1

snappy/snap/t3mlite/face.py

@@ -0,0 +1,37 @@
+# $$
+#   t3m - software for studying triangulated 3-manifolds
+#   Copyright (C) 2002 Marc Culler, Nathan Dunfield and others
+#
+#   This program is distributed under the terms of the
+#   GNU General Public License, version 2 or later, as published by
+#   the Free Software Foundation.  See the file GPL.txt for details.
+
+from .arrow import Arrow
+from .simplex import PickAnEdge
+
+
+class Face:
+    def __init__(self):
+        self.Index = -1
+        self.IntOrBdry = ''
+        self.Corners = []      # Corners of type "2-simplex in Tetrahedron"
+
+    def __repr__(self):
+        if self.Index > -1:
+            return ('f' + str(self.Index)
+                    + ' (' + self.IntOrBdry + ')')
+        else:
+            return '< floating face' + str(id(self)) + ' >'
+
+    def erase(self):
+        for corner in self.Corners:
+            corner.Tetrahedron.Class[corner.Subsimplex] = None
+        self.Index = -1
+
+    def bdry_arrow(self):
+        if self.IntOrBdry != 'bdry':
+            return None
+        face = self.Corners[0].Subsimplex
+        tet = self.Corners[0].Tetrahedron
+        edge = PickAnEdge[face]
+        return Arrow(edge, face, tet)

snappy/snap/t3mlite/files.py

@@ -0,0 +1,211 @@
+#   t3m - software for studying triangulated 3-manifolds
+#   Copyright (C) 2002 Marc Culler, Nathan Dunfield and others
+#
+#   This program is distributed under the terms of the
+#   GNU General Public License, version 2 or later, as published by
+#   the Free Software Foundation.  See the file GPL.txt for details.
+
+from .arrow import eArrow
+from .simplex import *
+from .tetrahedron import Tetrahedron
+import re
+
+# Nathan's code for importing and exporting snappea files.
+# Converts a SnapPea file to MComplex.  Doesn't really use all the
+# structure of the SnapPea file as it relies only on the fact that the
+# gluing data for the ith pair of tetrahedra is given by the ith pair
+# of lines like:
+#
+#      2    5    1   34
+#   3120 0321 0132 0132
+
+
+def read_SnapPea_file(file_name=None, data=None):
+    if data is None:
+        data = open(file_name).read().decode('ascii')
+    count = 0
+
+    neighbors_match = r"^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s*$"
+    perm_match = r"\s*([0123]{4,4})\s+([0123]{4,4})\s+([0123]{4,4})\s+([0123]{4,4})\s*$"
+    snappea_re = re.compile(neighbors_match + perm_match, re.MULTILINE)
+
+    fake_tets = []
+
+    curr_poss = 0
+    while 1:
+        m = snappea_re.search(data, curr_poss)
+        if not m:
+            break
+        else:
+            neighbors = [int(g) for g in m.group(1,2,3,4)]
+            perms = []
+            for perm in m.group(5,6,7,8):
+                perm = [int(p) for p in [perm[0], perm[1], perm[2], perm[3]]]
+                perms.append(perm)
+            fake_tets.append( (neighbors, perms) )
+            curr_poss = m.end(8)
+    return fake_tets
+
+# ------------End function SnapPea to Mcomplex--------------------
+
+
+# Exports an Mcomplex in SnapPea 2.0 format.
+# ASSUMES THAT THE MANIFOLD IS ORIENTABLE AND THAT THE LINK OF
+# ANY VERTEX HAS GENUS AT MOST ONE.
+
+def write_SnapPea_file(mcomplex, fileobject):
+    out = fileobject.write
+    if hasattr(fileobject, 'name'):
+        name = fileobject.name
+    else:
+        name = 'untitled'
+
+    out("% Triangulation\n\n" + name + "\nnot_attempted 0.0\nunknown_orientability\nCS_unknown\n\n")
+
+    torus_cusps = []
+    for vertex in mcomplex.Vertices:
+        g = vertex.link_genus()
+        if g > 1:
+            raise ValueError("Link of vertex has genus more than 1.")
+        if g == 1:
+            torus_cusps.append(vertex)
+
+    # All torus cusps are unfilled
+
+    out("%d 0\n" % len(torus_cusps))
+    for i in torus_cusps:
+        out( "   torus   0.000000000000   0.000000000000\n" )
+
+    out("\n")
+
+    # The num of tetrahedra
+
+    out("%d\n" % len(mcomplex))
+
+    # Output the tetraheda themselves.
+
+    for tet in mcomplex.Tetrahedra:
+        for face in TwoSubsimplices:
+            out("    %d" % mcomplex.Tetrahedra.index( tet.Neighbor[face]))
+        out("\n")
+        for face in TwoSubsimplices:
+            out(" %d%d%d%d" % tet.Gluing[face].tuple())
+
+        out("\n")
+        for vert in ZeroSubsimplices:
+            vertex = tet.Class[vert]
+            if vertex.link_genus() == 1:
+                out("%d " % torus_cusps.index(vertex))
+            else:
+                out("-1 ")
+        out("\n")
+        if hasattr(tet, 'PeripheralCurves'):
+            for curve in tet.PeripheralCurves:
+                for sheet in curve:
+                    for v in ZeroSubsimplices:
+                        for f in TwoSubsimplices:
+                            out("%d " % sheet[v][f])
+                        if v == V3:
+                            out("\n")
+                        else:
+                            out("  ")
+        else:
+            for i in range(4):
+                out("0 0 0 0  0 0 0 0   0 0 0 0   0 0 0 0\n")
+        out("0.0 0.0\n\n")
+
+
+# Nathan's code for importing and exporting geo files.
+#
+# converts Casson's u, v, w, x into 0, 1, 2, 3
+
+conv = {"u" : V0, "v" : V1, "w" : V2, "x" : V3}
+conv_back = {V0: "u", V1 : "v", V2 : "w", V3: "x"}
+
+# Geo saves edges in the form "5ux".  This function returns
+# (tet_num, starting_vertex, ending_vertex).  Because Casson
+# starts his indexing of tets at 1 and Jeff starts at 0,
+# we subtract 1.
+
+
+def read_edge(edge):
+    m = re.match("([0-9]+)([uvwx])([uvwx])", edge)
+    return (int(m.group(1)) - 1, conv[m.group(2)], conv[m.group(3)])
+
+#  Geo stores manifolds by storing the link around each edge.  This
+#  function takes two successive edges in the link and glues the
+#  corresponding tetrahedra together.
+
+
+def read_geo_file(file_name, num_tet=None):
+    data = open(file_name).readlines()
+    if num_tet is None:
+        num_tet = len(data) - 2
+    tets = []
+    for i in range(num_tet):
+        tets.append(Tetrahedron())
+
+    for line in data[1  : ]:
+        line = line.decode('ascii')
+        cycle = re.split(r"\s+", line[ : -1])[1 : ]
+        for i in range(len(cycle)):
+            t1, v1, v2 = read_edge(cycle[i])
+            t2, w1, w2 = read_edge(cycle[(i+1) % len(cycle)])  # Yes, that's w2, w1
+            a = eArrow(tets[t1], v1, v2)
+            b = eArrow(tets[t2], w1, w2)
+            a.glue(b)
+
+    return Mcomplex(tets)
+
+# ---------Code to go from Mcomplex to Geo---------------------
+
+
+def write_geo_file(mcomplex, fileobject):
+    out = fileobject.write
+    out("k\n")
+    i = 1
+    for edge in mcomplex.Edges:
+        tet = edge.Corners[0].Tetrahedron
+        edge_name = edge.Corners[0].Subsimplex
+        init = Head[edge_name]
+        fin = Tail[edge_name]
+        a = eArrow(tet, init, fin).opposite()
+        b = a.copy()
+        out("%d\t%d%s%s " % (i, mcomplex.Tetrahedra.index(b.Tetrahedron) + 1,
+                             conv_back[b.tail()], conv_back[b.head()]))
+        b.next()
+        while b != a:
+            out("%d%s%s " % (mcomplex.Tetrahedra.index(b.Tetrahedron) + 1,
+                             conv_back[b.tail()], conv_back[b.head()]))
+            b.next()
+
+        i = i + 1
+        out("\n")
+
+
+# writing a file for Matveev's program Spine
+
+def write_spine_file(mcomplex, fileobject):
+    out = fileobject.write
+    for edge in mcomplex.Edges:
+        n = edge.valence()
+        A = edge.get_arrow()
+        tets, global_faces, local_faces, back_local_faces = [], [], [], []
+        for i in range(n):
+            tets.append(A.Tetrahedron.Index + 1)
+            global_faces.append(A.Tetrahedron.Class[A.Face].Index + 1)
+            local_faces.append(A.Face)
+            back_local_faces.append(comp(A.head()))
+            A.next()
+
+        signs = [1 if (tets[i], local_faces[i]) < (tets[(i + 1) % n], back_local_faces[(i + 1) % n]) else -1 for i in range(n)]
+        ans = repr([signs[i]*global_faces[i] for i in range(n)])[1:-1].replace(",", "")
+        out(ans + "\n")
+
+
+__all__ = ('read_SnapPea_file',
+            'write_SnapPea_file',
+            'read_geo_file',
+            'write_geo_file',
+            'write_spine_file',
+            )

snappy/snap/t3mlite/homology.py

@@ -0,0 +1,53 @@
+from .simplex import *
+from .linalg import Matrix
+
+
+def boundary_three(manifold):
+    F, T = len(manifold.Faces), len(manifold.Tetrahedra)
+    ans = Matrix(F, T)
+    for F in manifold.Faces:
+        t0, t1 = (C.Tetrahedron.Index for C in F.Corners)
+        ans[F.Index, t0] += 1
+        ans[F.Index, t1] += -1
+    return ans
+
+
+def boundary_two(manifold):
+    VerticesOfFace = { F0 : (V1, V2, V3), F1 : (V0, V3, V2), F2 : (V0, V1, V3), F3 :
+                       (V0, V2, V1) }
+
+    E, F = len(manifold.Edges), len(manifold.Faces)
+    ans = Matrix(E, F)
+    for F in manifold.Faces:
+        C = F.Corners[0]
+        tet = C.Tetrahedron
+        vertices = VerticesOfFace[C.Subsimplex]
+        for i in range(3):
+            a, b = vertices[i], vertices[(i + 1) % 3]
+            e = tet.Class[a | b]
+            ans[e.index(), F.Index] += e.orientation_with_respect_to(tet, a, b)
+    return ans
+
+
+def boundary_one(manifold):
+    V, E = len(manifold.Vertices), len(manifold.Edges)
+    ans = Matrix(V, E)
+    for e in manifold.Edges:
+        v_init, v_term = (v.Index for v in e.Vertices)
+        ans[v_term, e.Index] += 1
+        ans[v_init, e.Index] += -1
+    return ans
+
+
+def boundary_maps(manifold):
+    """
+    The boundary maps in the homology chain complex of the
+    underlying cell-complex of a Mcomplex.
+
+    >>> M = Mcomplex('o9_12345')
+    >>> len(M.boundary_maps()) == 3
+    True
+    """
+    B1, B2, B3 = boundary_one(manifold), boundary_two(manifold), boundary_three(manifold)
+    assert B1*B2 == 0 and B2*B3 == 0
+    return B1, B2, B3