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

snappy/snap/t3mlite/perm4.py

@@ -1,37 +1,47 @@
-#$Id: perm4.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 
+#   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])
-    dict = {(0,1) : (2,3), (2, 0):(1, 3), (1,2):(0,3)}
-    for k in list(dict.keys()):
-        dict[dict[k]] = k
-        dict[swap(dict[k])] = swap(k)
-        dict[swap(k)] = swap(dict[k])
-    return 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 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.
 
-class Perm4:
+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 len(init) == 4:
+        if isinstance(init, Perm4Basic) or len(init) == 4:
             for i in range(4):
                 self.dict[i] = init[i]
         else:
@@ -42,127 +52,269 @@ class Perm4:
             self.dict[x[0]] = y[sign]
             self.dict[x[1]] = y[1-sign]
 
-    # A subset of {0,1,2,3} can be represented by a bitmap.  This computes
-    # the bitmap of the image subset.
     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
-        mask = 1
         for i in range(4):
             if bitmap & (1 << i):
                 image = image | (1 << self.dict[i])
-        return  image
+        return image
 
     def __repr__(self):
-        return(str(self.tuple()))
+        return str(self.tuple())
 
-    # P((i, ... ,j)) returns the image tuple (P(i), ... , P(j))
     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)
 
-    # P[i] returns the image of i, P(i)
     def __getitem__(self, index):
+        """
+        P[i] returns the image of i, P(i)
+
+        >>> Perm4Basic([2, 3, 1, 0])[3]
+        0
+        """
         return self.dict[index]
 
-    # P*Q is the composition P*Q(i) = P(Q(i))
     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 Perm4(composition)
+        return Perm4Basic(composition)
 
-    # inv(P) is the inverse permutation 
     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 Perm4(inverse)
+        return Perm4Basic(inverse)
 
-    # sign(P) is the sign: 0 for even, 1 for odd
     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
 
-    # P.tuple() returns a tuple representing the permutation P
     def tuple(self):
-        the_tuple = ()
-        for i in range(4):
-            the_tuple = the_tuple + (self.dict[i],)
-        return the_tuple
-
-    _rawS4 = [ (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) ]
+        """
+        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
-        """
 
-        for p in Perm4._rawS4:
+        >>> len(list(Perm4.S4()))
+        24
+        """
+        for p in S4_tuples:
             yield Perm4(p)
 
-    _rawA4 = [ (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)]
-
     @staticmethod
     def A4():
         """
         All even permutations in A4
-        """
 
-        for p in Perm4._rawA4:
+        >>> len(list(Perm4.A4()))
+        12
+        """
+        for p in A4_tuples:
             yield Perm4(p)
 
-    _rawKleinFour = [ (0,1,2,3),  # Id
-                      (1,0,3,2),  # (01)(23)
-                      (2,3,0,1),  # (02)(13)
-                      (3,2,1,0) ] # (03)(12)
-
     @staticmethod
     def KleinFour():
         """
         Z/2 x Z/2 as a subgroup of A4.
-        """
 
-        for p in Perm4._rawKleinFour:
+        >>> 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

@@ -1,13 +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':''}
+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

@@ -1,13 +1,11 @@
-#$Id: simplex.py,v 1.4 2010/07/12 21:14:01 t3m Exp $
+# $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 
+#   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 .perm4 import *
-
 # Global definitions dealing with simplices
 SimplexError = 'Error'
 
@@ -16,22 +14,22 @@ SimplexError = 'Error'
 # by a binary number between 0 and 15.  We name the subsets as
 # follows:
 
-N   = 0  # 0000
-V0  = 1  # 0001
-V1  = 2  # 0010
+N = 0  # 0000
+V0 = 1  # 0001
+V1 = 2  # 0010
 E01 = 3  # 0011 <-----|
-V2  = 4  # 0100       |
+V2 = 4  # 0100       |
 E02 = 5  # 0101 <---| |
 E21 = 6  # 0110 <-| | |
-F3  = 7  # 0111   | | |
-V3  = 8  # 1000   | | |  Opposite edges
+F3 = 7  # 0111   | | |
+V3 = 8  # 1000   | | |  Opposite edges
 E03 = 9  # 1001 <-| | |
 E13 = 10 # 1010 <---| |
-F2  = 11 # 1011       |
+F2 = 11 # 1011       |
 E32 = 12 # 1100 <-----|
-F1  = 13 # 1101
-F0  = 14 # 1110
-T   = 15 # 1111
+F1 = 13 # 1101
+F0 = 14 # 1110
+T = 15 # 1111
 
 # User-friendly?
 
@@ -43,26 +41,29 @@ 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  
+    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 
-#  \  |  /  
-#   \ | /   
-#    \|/    
+# A simplex is oriented like this:
+#     1
+#    /|\
+#   / | \
+#  /  |  \
+# 2---|---3
+#  \  |  /
+#   \ | /
+#    \|/
 #     0
 #
 # This is the same as SnapPea's default right_handed orientation.
@@ -70,22 +71,22 @@ SubsimplexName = ('N', 'V0', 'V1', 'E01', 'V2', 'E02', 'E12', 'F3',
 # 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)} 
+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
@@ -101,9 +102,9 @@ EdgeTuple= { E01:(0,1), E02:(0,2), E21:(2,1), E03:(0,3), E13:(1,3), E32:(3,2)}
 #    \|/
 
 
-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 }
+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.
@@ -136,7 +137,7 @@ OneSubsimplices = (E01,E02,E21,E03,E13,E32)
 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 }
+FaceIndex = {F0: 0, F1: 1, F2: 2, F3: 3}
 
 # This dictionary maps a directed edge to the tail of its opposite.
 
@@ -161,22 +162,38 @@ VerticesOfFaceCounterclockwise = {
     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 1
+    return 0
 
 # Return the complement of a subsimplex
+
+
 def comp(subsimplex):
     return ~subsimplex & 0xf
 
-# Given and edge and a face, return the other face that meets the edge.
-def flip_face(edge, face):
-    #  if is_subset(edge, face):
-    return edge | ~face & 0xf
-#  else:
-#    raise SimplexError, 'flip_face: Edge not contained in face.'
 
+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}