snappy 3.2__cp311-cp311-macosx_10_12_x86_64.whl

snappy/snap/t3mlite/perm4.py

@@ -0,0 +1,320 @@
+#   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 operator import inv
+
+
+def _make_opp_dict():
+    def swap(t):
+        return (t[1], t[0])
+    dic = {(0, 1): (2, 3), (2, 0): (1, 3), (1, 2): (0, 3)}
+    for k in list(dic):
+        dic[dic[k]] = k
+        dic[swap(dic[k])] = swap(k)
+        dic[swap(k)] = swap(dic[k])
+    return dic
+
+
+# opposite[(i,j)] = (k,l), where i,j,k,l are distinct and the permutation
+# 0->i,1->j,2->k,3->l is even.
+
+opposite = _make_opp_dict()
+
+
+class Perm4Basic:
+    """
+    Class Perm4Basic: A permutation of {0,1,2,3}.
+
+    A permutation can be initialized with a length 4 dictionary or a
+    4-tuple or a length 2 dictionary; in the latter case the sign of
+    the permutation can be specified by setting "sign=0" (even) or
+    "sign=1" (odd).  The default sign is odd, since odd permutations
+    describe orientation-preserving gluings.
+
+    This is the original version of Perm4, which was tablized for
+    speed reasons.
+    """
+
+    def __init__(self, init, sign=1):
+        self.dict = {}
+        if isinstance(init, Perm4Basic) or len(init) == 4:
+            for i in range(4):
+                self.dict[i] = init[i]
+        else:
+            self.dict = init
+            v = list(init.items())
+            x = opposite[(v[0][0],v[1][0])]
+            y = opposite[(v[0][1],v[1][1])]
+            self.dict[x[0]] = y[sign]
+            self.dict[x[1]] = y[1-sign]
+
+    def image(self, bitmap):
+        """
+        A subset of {0,1,2,3} can be represented by a bitmap.  This
+        computes the bitmap of the image subset.
+
+        >>> Perm4Basic([2, 3, 1, 0]).image(10)
+        9
+        """
+        image = 0
+        for i in range(4):
+            if bitmap & (1 << i):
+                image = image | (1 << self.dict[i])
+        return image
+
+    def __repr__(self):
+        return str(self.tuple())
+
+    def __call__(self, a_tuple):
+        """
+        P((i, ... ,j)) returns the image tuple (P(i), ... , P(j))
+        """
+        image = []
+        for i in a_tuple:
+            image.append(self.dict[i])
+        return tuple(image)
+
+    def __getitem__(self, index):
+        """
+        P[i] returns the image of i, P(i)
+
+        >>> Perm4Basic([2, 3, 1, 0])[3]
+        0
+        """
+        return self.dict[index]
+
+    def __mul__(self, other):
+        """
+        P*Q is the composition P*Q(i) = P(Q(i))
+
+        >>> P = Perm4Basic((2, 3, 1, 0))
+        >>> Q = Perm4Basic((1, 0, 2, 3))
+        >>> P * Q
+        (3, 2, 1, 0)
+        >>> Q * P
+        (2, 3, 0, 1)
+        """
+        composition = {}
+        for i in range(4):
+            composition[i] = self.dict[other.dict[i]]
+        return Perm4Basic(composition)
+
+    def __invert__(self):
+        """
+        inv(P) is the inverse permutation
+
+        >>> inv(Perm4Basic([2, 1, 3, 0]))
+        (3, 1, 0, 2)
+        """
+        inverse = {}
+        for i in range(4):
+            inverse[self.dict[i]] = i
+        return Perm4Basic(inverse)
+
+    def sign(self):
+        """
+        sign(P) is the sign: 0 for even, 1 for odd
+
+        >>> Perm4Basic([0, 1, 3, 2]).sign()
+        1
+        >>> Perm4Basic([1, 0, 3, 2]).sign()
+        0
+        """
+        sign = 0
+        for (i,j) in [(0,1),(0,2),(0,3),(1,2),(1,3),(2,3)]:
+            sign = sign ^ (self.dict[i] < self.dict[j])
+        return sign
+
+    def tuple(self):
+        """
+        P.tuple() returns a tuple representing the permutation P
+
+        >>> Perm4Basic([1, 2, 0, 3]).tuple()
+        (1, 2, 0, 3)
+        """
+        return tuple(self.dict[i] for i in range(4))
+
+
+S4_tuples = [(0,1,2,3), (0,1,3,2), (0,2,1,3), (0,2,3,1), (0,3,1,2), (0,3,2,1),
+             (1,0,2,3), (1,0,3,2), (1,2,0,3), (1,2,3,0), (1,3,0,2), (1,3,2,0),
+             (2,0,1,3), (2,0,3,1), (2,1,0,3), (2,1,3,0), (2,3,0,1), (2,3,1,0),
+             (3,0,1,2), (3,0,2,1), (3,1,0,2), (3,1,2,0), (3,2,0,1), (3,2,1,0)]
+
+A4_tuples = [(0,1,2,3), (0,2,3,1), (0,3,1,2), (1,0,3,2), (1,2,0,3), (1,3,2,0),
+             (2,0,1,3), (2,1,3,0), (2,3,0,1), (3,0,2,1), (3,1,0,2), (3,2,1,0)]
+
+KleinFour_tuples = [(0,1,2,3),  # Id
+                    (1,0,3,2),  # (01)(23)
+                    (2,3,0,1),  # (02)(13)
+                    (3,2,1,0) ] # (03)(12)
+
+perm_tuple_to_index = {t:i for i, t in enumerate(S4_tuples)}
+perm_basic_by_index = [Perm4Basic(t) for t in S4_tuples]
+
+
+def perm_basic_to_index(perm):
+    return perm_tuple_to_index[perm.tuple()]
+
+
+perm_signs_by_index = {i: perm.sign()
+                       for i, perm in enumerate(perm_basic_by_index)}
+
+bitmap_images = {(i, bitmap): perm.image(bitmap)
+                 for bitmap in range(16)
+                 for i, perm in enumerate(perm_basic_by_index)}
+
+index_of_inverse_by_index = {i: perm_basic_to_index(inv(perm))
+                             for i, perm in enumerate(perm_basic_by_index)}
+
+index_mult_table_by_index = {(i, j): perm_basic_to_index(P * Q)
+                       for i, P in enumerate(perm_basic_by_index)
+                       for j, Q in enumerate(perm_basic_by_index)}
+
+
+class Perm4():
+    """
+    Class Perm4: A permutation of {0,1,2,3}.
+
+    A permutation can be initialized with a length 4 dictionary or a
+    4-tuple or a length 2 dictionary; in the latter case the sign of
+    the permutation can be specified by setting "sign=0" (even) or
+    "sign=1" (odd).  The default sign is odd, since odd permutations
+    describe orientation-preserving gluings.
+    """
+
+    def __init__(self, init, sign=1):
+        if isinstance(init, int):
+            self._index = init
+            self._tuple = S4_tuples[init]
+        elif isinstance(init, Perm4):
+            self._index = init._index
+            self._tuple = init._tuple
+        elif len(init) == 4:
+            self._tuple = tuple(init[i] for i in range(4))
+            self._index = perm_tuple_to_index[self._tuple]
+        else:
+            self._tuple = Perm4Basic(init, sign).tuple()
+            self._index = perm_tuple_to_index[self._tuple]
+
+    def image(self, bitmap):
+        """
+        A subset of {0,1,2,3} can be represented by a bitmap.  This
+        computes the bitmap of the image subset.
+
+        >>> Perm4([2, 3, 1, 0]).image(10)
+        9
+        """
+        return bitmap_images[self._index, bitmap]
+
+    def __repr__(self):
+        return str(self._tuple)
+
+    def __call__(self, a_tuple):
+        """
+        P((i, ... ,j)) returns the image tuple (P(i), ... , P(j))
+
+        >>> Perm4([2, 3, 1, 0])(range(3))
+        (2, 3, 1)
+        """
+        image = []
+        for i in a_tuple:
+            image.append(self._tuple[i])
+        return tuple(image)
+
+    def __getitem__(self, index):
+        """
+        P[i] returns the image of i, P(i)
+
+        >>> Perm4([2, 3, 1, 0])[3]
+        0
+        """
+        return self._tuple[index]
+
+    def __mul__(self, other):
+        """
+        P*Q is the composition P*Q(i) = P(Q(i))
+
+        >>> P = Perm4((2, 3, 1, 0))
+        >>> Q = Perm4((1, 0, 2, 3))
+        >>> P * Q
+        (3, 2, 1, 0)
+        >>> Q * P
+        (2, 3, 0, 1)
+        """
+        return mult_table_by_index[self._index, other._index]
+
+    def __invert__(self):
+        """
+        inv(P) is the inverse permutation
+
+        >>> inv(Perm4([2, 1, 3, 0]))
+        (3, 1, 0, 2)
+        """
+        return inverse_by_index[self._index]
+
+    def sign(self):
+        """
+        sign(P) is the sign: 0 for even, 1 for odd
+
+        >>> Perm4([0, 1, 3, 2]).sign()
+        1
+        >>> Perm4([1, 0, 3, 2]).sign()
+        0
+        """
+        return perm_signs_by_index[self._index]
+
+    def tuple(self):
+        """
+        P.tuple() returns a tuple representing the permutation P
+
+        >>> Perm4([1, 2, 0, 3]).tuple()
+        (1, 2, 0, 3)
+        """
+        return self._tuple
+
+    @staticmethod
+    def S4():
+        """"
+        All permutations in S4
+
+        >>> len(list(Perm4.S4()))
+        24
+        """
+        for p in S4_tuples:
+            yield Perm4(p)
+
+    @staticmethod
+    def A4():
+        """
+        All even permutations in A4
+
+        >>> len(list(Perm4.A4()))
+        12
+        """
+        for p in A4_tuples:
+            yield Perm4(p)
+
+    @staticmethod
+    def KleinFour():
+        """
+        Z/2 x Z/2 as a subgroup of A4.
+
+        >>> len(list(Perm4.KleinFour()))
+        4
+        """
+        for p in KleinFour_tuples:
+            yield Perm4(p)
+
+
+inverse_by_index = {k:Perm4(v) for k, v in index_of_inverse_by_index.items()}
+mult_table_by_index = {k:Perm4(v) for k, v in index_mult_table_by_index.items()}
+
+__all__ = ["Perm4", "inv"]
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

snappy/snap/t3mlite/setup.py

@@ -0,0 +1,12 @@
+from distutils.core import setup
+
+setup(
+    name="t3m",
+    version="",
+    description="Tinker toys for topologists",
+    author="Marc Culler and Nathan Dunfield",
+    author_email="culler@math.uic.edu, dunfield@caltech.edu",
+    url="http://www.math.uic.edu/~t3m",
+    packages=['t3m'],
+    package_dir={'t3m': ''}
+)

snappy/snap/t3mlite/simplex.py

@@ -0,0 +1,199 @@
+# $Id: simplex.py,v 1.4 2010/07/12 21:14:01 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.
+
+# Global definitions dealing with simplices
+SimplexError = 'Error'
+
+# The subsimplices of a 3-simplex correspond to the subsets of a 4
+# element set.  A subset of a 4-element set is represented as a bitmap
+# by a binary number between 0 and 15.  We name the subsets as
+# follows:
+
+N = 0  # 0000
+V0 = 1  # 0001
+V1 = 2  # 0010
+E01 = 3  # 0011 <-----|
+V2 = 4  # 0100       |
+E02 = 5  # 0101 <---| |
+E21 = 6  # 0110 <-| | |
+F3 = 7  # 0111   | | |
+V3 = 8  # 1000   | | |  Opposite edges
+E03 = 9  # 1001 <-| | |
+E13 = 10 # 1010 <---| |
+F2 = 11 # 1011       |
+E32 = 12 # 1100 <-----|
+F1 = 13 # 1101
+F0 = 14 # 1110
+T = 15 # 1111
+
+# User-friendly?
+
+E10 = 3
+E20 = 5
+E12 = 6
+E30 = 9
+E31 = 10
+E23 = 12
+
+# Generate a bitmap from a tuple of vertices.
+
+
+def bitmap(tuple):
+    bmap = 0
+    for i in tuple:
+        bmap = bmap | (1 << i)
+    return bmap
+
+# This list of subsimplex names can be used for printing.
+
+
+SubsimplexName = ('N', 'V0', 'V1', 'E01', 'V2', 'E02', 'E12', 'F3',
+                  'V3', 'E03', 'E31', 'F2', 'E23', 'F1', 'F0', 'T')
+
+# A simplex is oriented like this:
+#     1
+#    /|\
+#   / | \
+#  /  |  \
+# 2---|---3
+#  \  |  /
+#   \ | /
+#    \|/
+#     0
+#
+# This is the same as SnapPea's default right_handed orientation.
+#
+# Each edge has a default orientation.  The edge directions are chosen
+# so that vertex 0 is a source and so that a simplex looks like this
+# when viewed from any edge:
+#     *
+#    /|\
+#   / ^ \
+#  /  |  \
+# *-<-|---*
+#  \  |  /
+#   \ | /
+#    \|/
+#     *
+
+# These dictionaries associate to each edge its initial vertex, terminal
+# vertex, or a tuple containing both.
+
+Tail = { E01:V0   , E02:V0   , E21:V2   , E03:V0   , E13:V1   , E32:V3   }
+Head = { E01:V1   , E02:V2   , E21:V1   , E03:V3   , E13:V3   , E32:V2   }
+EdgeTuple = { E01:(0,1), E02:(0,2), E21:(2,1), E03:(0,3), E13:(1,3), E32:(3,2)}
+
+# These dictionaries associate to each edge a face containing it.  If
+# the terminal vertex of the edge is on top then the associated face
+# is to the right (left, top, bottom) of the edge.
+
+#     ^
+#    /|\
+#   / | \ <-T
+#  /  |  \
+#  -L-|-R-
+#  \  |  /
+#   \ | / <-B
+#    \|/
+
+
+RightFace = { E01:F2 , E02:F3 , E21:F3 , E03:F1 , E13:F2 , E32:F1 }
+LeftFace = { E01:F3 , E02:F1 , E21:F0 , E03:F2 , E13:F0 , E32:F0 }
+TopFace = { E01:F0 , E02:F0 , E21:F2 , E03:F0 , E13:F1 , E32:F3 }
+BottomFace = { E01:F1 , E02:F2 , E21:F1 , E03:F3 , E13:F3 , E32:F2 }
+
+# This dictionary associates to each face an edge contained in it.
+
+PickAnEdge = { F0:E21 , F1:E23, F2:E03, F3:E01}
+
+# This dictionary associates to each edge its opposite edge.
+OppositeEdge = { E01:E23, E02:E13, E03:E12, E12:E03, E13:E02, E23:E01 }
+
+# This dictionary associates to each edge a list of the edges which
+# are not opposite to it.
+
+AdjacentEdges = { E01:(E02,E03,E12,E13),
+                  E02:(E01,E03,E12,E23),
+                  E03:(E01,E02,E13,E23),
+                  E12:(E01,E02,E13,E23),
+                  E13:(E01,E03,E12,E23),
+                  E23:(E02,E03,E12,E13) }
+
+# Loops that run through all subsimplices of a given dimension
+# can use these lists of bitmaps as index sets.
+
+# A list of all faces:
+TwoSubsimplices = (F0,F1,F2,F3)
+
+# A list of all edges:
+OneSubsimplices = (E01,E02,E21,E03,E13,E32)
+
+# A list of all vertices:
+ZeroSubsimplices = (V0,V1,V2,V3)
+
+# This dictionary maps the bitmap of a face to its index.
+FaceIndex = {F0: 0, F1: 1, F2: 2, F3: 3}
+
+# This dictionary maps a directed edge to the tail of its opposite.
+
+OppTail = {(V0,V1):V3,(V0,V2):V1,(V0,V3):V2,(V1,V2):V3,(V1,V3):V0,(V2,V3):V1,
+           (V1,V0):V2,(V2,V0):V3,(V3,V0):V1,(V2,V1):V0,(V3,V1):V2,(V3,V2):V0}
+
+# This dictionary maps each vertex to the three adjacent faces in
+# counter-clockwise order
+FacesAroundVertexCounterclockwise = {
+    V0: (F1, F2, F3),
+    V1: (F0, F3, F2),
+    V2: (F0, F1, F3),
+    V3: (F0, F2, F1)
+}
+
+# This dictionary maps each faces to the three adjacent vertices in
+# counter-clockwise order
+VerticesOfFaceCounterclockwise = {
+    F0: (V3, V2, V1),
+    F1: (V2, V3, V0),
+    F2: (V3, V1, V0),
+    F3: (V1, V2, V0)
+}
+
+# Dimension of a subsimplex
+def dimension(x):
+    if x in ZeroSubsimplices:
+        return 0
+    if x in OneSubsimplices:
+        return 1
+    if x in TwoSubsimplices:
+        return 2
+    if x == T:
+        return 3
+    raise Exception("%r is not a subsimplex" % x)
+
+# Decide if the bitmap x represents a subset of the bitmap y
+
+
+def is_subset(x, y):
+    if (x & y == x):
+        return 1
+    return 0
+
+# Return the complement of a subsimplex
+
+
+def comp(subsimplex):
+    return ~subsimplex & 0xf
+
+
+EdgeFacePairs = [(edge, face) for face in TwoSubsimplices
+                              for edge in OneSubsimplices
+                              if is_subset(edge, face)]
+
+# Given and edge and a face, return the other face that meets the edge.
+
+flip_face = {(edge, face):(edge | ~face & 0xf)
+             for edge, face in EdgeFacePairs}