snappy 3.2__cp311-cp311-macosx_10_12_x86_64.whl

snappy/snap/t3mlite/arrow.py

@@ -0,0 +1,243 @@
+# $Id: arrow.py,v 1.3 2003/04/30 19:59:58 t3m 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 .perm4 import Perm4, inv
+
+# I have implemented Casson's Arrow as a class whose attributes are
+# "an edge in a face in a tetrahedron".  The Edge attribute is the
+# (unoriented) edge opposite to the arrow, if the arrow is thought of
+# as a directed edge.  The Face attribute is the face that is disjoint
+# from the directed edge, except that it contains the head vertex,
+# i.e. the Face is the face that is normally associated to the arrow
+# when the arrow is used for gluing faces together.
+
+# The eArrow class is an extension of Arrow that is initialized by
+# specifying the head and tail vertices.
+
+# I have followed Nathan's convention that a "null arrow" is an arrow
+# whose Tetrahedron attribute is None.  If an arrow A represents a
+# boundary face then A.glued() is a null arrow.  If either A or B is a
+# Null Arrow then both A.glue(B) and B.glue(A) cause the appropriate
+# Neighbor of the non-None Tetrahedron to be set to None, creating a
+# boundary face.  This trick allows deceptively short code to be used
+# in writing the two_to_zero move.  NOTE:  The Arrow.next method does NOT
+# return a null arrow if the face is a boundary face.  It returns None.
+
+# Arrows seem to be handy for gluing tetrahedra together without too
+# much fussing about how vertices of a tetrahedron are numbered.
+# I have not tried to figure out how they will break if you try to
+# use them in a non-orientable manifold.
+
+
+# For speed, we create a lookup table for all possible gluing permutations
+
+_arrow_gluing_dict = {}
+for edge0, face0 in EdgeFacePairs:
+    for edge1, face1 in EdgeFacePairs:
+        perm = Perm4({FaceIndex[face0]:FaceIndex[flip_face[edge1, face1]],
+                      FaceIndex[flip_face[edge0, face0]]:FaceIndex[face1]})
+        glued_face = perm.image(face0)
+        _arrow_gluing_dict[edge0, face0, edge1, face1] = (perm, inv(perm), glued_face)
+
+
+# Another table to speed Arrow.opposite
+
+_arrow_opposite_dict = {}
+for edge, face in EdgeFacePairs:
+    tail = comp(face)
+    head = face & comp(edge)
+    new_face = comp(OppTail[(tail, head)])
+    new_edge = comp(edge)
+    _arrow_opposite_dict[edge, face] = (new_edge, new_face)
+
+
+# Another table to speed Arrow.next
+
+_arrow_next_dict = {}
+for edge, face in EdgeFacePairs:
+    for perm in Perm4.S4():
+        new_edge = perm.image(edge)
+        new_face = flip_face[new_edge, perm.image(face)]
+        _arrow_next_dict[perm._index, edge, face] = (new_edge, new_face)
+
+
+class Arrow:
+
+    def __init__(self, edge, face, tet):
+        self.Edge = edge
+        self.Face = face
+        self.Tetrahedron = tet
+
+    def __repr__(self):
+        return ('< '+SubsimplexName[self.Edge]+' | ' +
+                SubsimplexName[self.Face]+' | '+str(self.Tetrahedron)+' >')
+
+    def head(self):
+        return self.Face & comp(self.Edge)
+
+    def tail(self):
+        return comp(self.Face)
+
+# Here are the six edges of the tetrahedron, as seen from the
+# point of view of the arrow.
+    def equator(self):
+        return self.Tetrahedron.Class[comp(self.Edge)]
+
+    def axis(self):
+        return self.Tetrahedron.Class[self.Edge]
+
+    def north_head(self):
+        return self.Tetrahedron.Class[self.head() | OppTail[self.head(),self.tail()]]
+
+    def south_head(self):
+        return self.Tetrahedron.Class[self.head() | OppTail[self.tail(),self.head()]]
+
+    def north_tail(self):
+        return self.Tetrahedron.Class[self.tail() | OppTail[self.head(),self.tail()]]
+
+    def south_tail(self):
+        return self.Tetrahedron.Class[self.tail() | OppTail[self.tail(),self.head()]]
+
+    def is_null(self):
+        return 1 if self.Tetrahedron is None else 0
+
+    def face_class(self):
+        return self.Tetrahedron.Class[self.Face]
+
+# Does NOT create a new arrow.
+    def reverse(self):
+        self.Face = flip_face[self.Edge, self.Face]
+        return self
+
+# By successive applications of self.next() you can walk around an edge.
+# The sequence of 1-subsimplices self.Edge are all equivalent.
+# The sequence of 2-subsimplices self.Face are the faces adjacent to the edge.
+# When you hit the boundary, self.next() returns None without changing self.
+# Does NOT create a new arrow.
+    def next(self):
+        if self.Tetrahedron is not None:
+            perm = self.Tetrahedron.Gluing[self.Face]
+            tet = self.Tetrahedron.Neighbor[self.Face]
+        if tet is None:
+            return None
+
+        # Next line equivalent to:
+        # self.Edge = perm.image(self.Edge)
+        # self.Face = flip_face[self.Edge, perm.image(self.Face)]
+        self.Edge, self.Face = _arrow_next_dict[perm._index, self.Edge, self.Face]
+        self.Tetrahedron = tet
+        return self
+
+# Glues two faces together so that other becomes self.next().
+# Returns None
+    def glue(self, other):
+        if self.Tetrahedron is None and other.Tetrahedron is None:
+            return
+        if self.Tetrahedron is None:
+            other.reverse().glue(self)
+            other.reverse()
+            return
+        if other.Tetrahedron is None:
+            self.Tetrahedron.attach(self.Face, None, (0,1,2,3))
+            return
+        # We do this manually for speed.  The below code is equivalent to
+        #
+        # self.Tetrahedron.attach(self.Face, other.Tetrahedron,
+        #                        { FaceIndex[self.Face]:FaceIndex[flip_face(other.Edge,other.Face)],
+        #                          FaceIndex[flip_face(self.Edge,self.Face)]:FaceIndex[other.Face] })
+        tet0, face0, edge0 = self.Tetrahedron, self.Face, self.Edge
+        tet1, face1, edge1 = other.Tetrahedron, other.Face, other.Edge
+        perm, inv_perm, glued_face = _arrow_gluing_dict[edge0, face0, edge1, face1]
+        tet0.Neighbor[face0] = tet1
+        tet0.Gluing[face0] = perm
+        tet1.Neighbor[glued_face] = tet0
+        tet1.Gluing[glued_face] = inv_perm
+
+    # Returns a COPY of self.next(), or a null arrow in the case of a boundary
+    # face.
+    # DOES create a new arrow.
+    def glued(self):
+        a = self.copy()
+        if a.next() is None:
+            a.Tetrahedron = None
+        return a
+
+    # Changes the arrow into its opposite.
+    # Does NOT create a new arrow.
+    def opposite(self):
+        # Equivalent to
+        # self.Face = comp(OppTail[(self.tail(),self.head())])
+        # self.Edge = comp(self.Edge)
+        self.Edge, self.Face = _arrow_opposite_dict[self.Edge, self.Face]
+        return self
+
+    # Rotate arrow n/3 turns clockwise about self.head()
+    # Does NOT create a new arrow
+    def rotate(self, n):
+        for i in range(n % 3):
+            head = self.head()
+            tail = self.tail()
+            self.Edge = tail | OppTail[(tail, head)]
+            self.Face = self.Edge | head
+        return self
+
+    # DOES create a new arrow.
+    def copy(self):
+        return Arrow(self.Edge, self.Face, self.Tetrahedron)
+
+    # Two arrows are equal if their attributes are equal.  The
+    # null arrows must be handled separately.  This also allows
+    # comparison with None.
+    def __eq__(self, other):
+        if other is None:
+            return False
+        if self.Tetrahedron is None and other.Tetrahedron is None:
+            return True
+        return (self.Tetrahedron == other.Tetrahedron and
+            self.Edge == other.Edge and
+            self.Face == other.Face)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+# The arrows associated to a given edge e form a cycle of edges linking
+# e.  This function returns a list of the edges in that linking cycle.
+    def linking_cycle(self):
+        a = self.copy()
+        cycle = []
+        while 1:
+            cycle.append(a.Tetrahedron.Class[OppositeEdge[a.Edge]])
+            a.next()
+            if a == self:
+                break
+        return cycle
+
+# This function returns a list of those edges that are adjacent to the
+# edge associated to the arrow, and meet it at its tail.
+    def radii(self):
+        a = self.copy()
+        radius_list = []
+        while 1:
+            a.rotate(2)
+            radius_list.append(a.Tetrahedron.Class[OppositeEdge[a.Edge]])
+            a.rotate(1).next()
+            if a == self:
+                break
+        return radius_list
+
+
+# This class allows one to initialize an arrow by specifying the head and
+# tail vertices of the directed edge.
+#
+class eArrow(Arrow):
+
+    def __init__(self, tet, tail, head):
+        self.Edge = comp( tail | head )
+        self.Face = comp( tail )
+        self.Tetrahedron = tet

snappy/snap/t3mlite/corner.py

@@ -0,0 +1,22 @@
+# $Id: corner.py,v 1.2 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 SubsimplexName
+
+# A Corner is a "subsimplex in a tetrahedron".
+
+
+class Corner:
+
+    def __init__(self, tetrahedron, subsimplex):
+        self.Tetrahedron = tetrahedron
+        self.Subsimplex = subsimplex
+
+    def __repr__(self):
+        return ('<'+SubsimplexName[self.Subsimplex] + ' of ' +
+                str(self.Tetrahedron) + '>')

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',
+            )