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

snappy/snap/shapes.py

@@ -1,80 +1,98 @@
 from ..sage_helper import _within_sage
-from ..pari import pari, prec_dec_to_bits, prec_bits_to_dec
+from ..pari import pari, prec_dec_to_bits, prec_bits_to_dec, Gen
+
 if _within_sage:
     from ..sage_helper import ComplexField
 else:
     from snappy.number import Number
 
-def is_pari(x):
-    return type(x) == type(pari(0))
+
+def is_pari(x) -> bool:
+    return isinstance(x, Gen)
+
 
 def pari_matrix(A):
-    return pari.matrix( len(A), len(A[0]), [ pari(x) for x in sum(A, []) ] )
+    return pari.matrix(len(A), len(A[0]), [pari(x) for x in sum(A, [])])
+
 
 def pari_row_vector(v):
     return pari(v).Vec()
 
+
 def pari_column_vector(v):
     return pari(v).Col()
 
+
 def pari_vector_to_list(v):
     return v.Vec().python_list()
 
+
 def pari_matrix_to_lists(A):
     'Return the entries of A in *column major* order'
     return [pari_vector_to_list(v) for v in A.list()]
 
+
 def eval_gluing_equation(eqn, shapes):
     if is_pari(eqn):
         shapes = pari_vector_to_list(shapes)
     a, b, c = eqn
     ans = int(c)
-    for i , z in enumerate(shapes):
-        ans = ans * ( z**int(a[i])   *  (1 - z) ** int(b[i]) )
+    for i, z in enumerate(shapes):
+        ans = ans * (z**int(a[i]) * (1 - z)**int(b[i]))
     return ans
-       
+
+
 def gluing_equation_errors(eqns, shapes):
     return [eval_gluing_equation(eqn, shapes) - 1 for eqn in eqns]
 
+
 def infinity_norm(L):
     if is_pari(L):
         L = pari_vector_to_list(L)
     return max([abs(x) for x in L])
 
+
 def gluing_equation_error(eqns, shapes):
     return infinity_norm(gluing_equation_errors(eqns, shapes))
 
+
 def enough_gluing_equations(manifold):
     """
-    Select a full-rank portion of the gluing equations.  
+    Select a full-rank portion of the gluing equations.
     """
     n_tet = manifold.num_tetrahedra()
     n_cusps = manifold.num_cusps()
     eqns = manifold.gluing_equations("rect")
-    edge_eqns = pari_matrix( [a + b for a,b,c in eqns[:n_tet]] )
-    edge_eqns_with_RHS = pari_matrix( [a + b + [(1-c)//2] for a,b,c in eqns[:n_tet]] )
+    edge_eqns = pari_matrix([a + b for a, b, _ in eqns[:n_tet]])
+    edge_eqns_with_RHS = pari_matrix([a + b + [(1 - c) // 2]
+                                      for a, b, c in eqns[:n_tet]])
     H, U = edge_eqns.mattranspose().mathnf(flag=1)
     assert H.ncols() == n_tet - n_cusps
     edge_eqns_with_RHS = pari_matrix_to_lists((edge_eqns_with_RHS.mattranspose() * U))[n_cusps:]
-    edge_eqns_with_RHS = [ (e[:n_tet], e[n_tet:2*n_tet], pari(-1)**e[-1]) for e in edge_eqns_with_RHS]
+    edge_eqns_with_RHS = [(e[:n_tet], e[n_tet: 2 * n_tet], pari(-1)**e[-1])
+                          for e in edge_eqns_with_RHS]
 
     cusp_eqns = []
     j = n_tet
     for i in range(n_cusps):
-        cusp_eqns.append( eqns[j])
+        cusp_eqns.append(eqns[j])
         j += 2 if manifold.cusp_info(i)['complete?'] else 1
 
     ans_eqns = edge_eqns_with_RHS + cusp_eqns
 
-    ans_matrix = pari_matrix( [a + b for a, b, c in ans_eqns ] )
+    ans_matrix = pari_matrix([a + b for a, b, _ in ans_eqns])
     assert len(ans_eqns) == n_tet and len(ans_matrix.mattranspose().matkerint()) == 0
     return [(list(map(int, A)), list(map(int, B)), int(c)) for A, B, c in ans_eqns]
 
+
 def float_to_pari(x, dec_prec):
     return pari(0) if x == 0 else pari(x).precision(dec_prec)
 
+
 def complex_to_pari(z, dec_prec):
-    return pari.complex( float_to_pari(z.real, dec_prec), float_to_pari(z.imag, dec_prec) )
+    return pari.complex(float_to_pari(z.real, dec_prec),
+                        float_to_pari(z.imag, dec_prec))
+
 
 def polished_tetrahedra_shapes(manifold, dec_prec=None, bits_prec=200, ignore_solution_type=False):
     """
@@ -91,21 +109,22 @@ def polished_tetrahedra_shapes(manifold, dec_prec=None, bits_prec=200, ignore_so
         CC = ComplexField(bits_prec)
         number = CC
     else:
-        number = lambda z: Number(z, precision=bits_prec)
+        def number(z):
+            return Number(z, precision=bits_prec)
 
     # This is a potentially long calculation, so we cache the result
 
-    if "polished_shapes" in manifold._cache.keys():
+    if "polished_shapes" in manifold._cache:
         curr_bits_prec, curr_sol = manifold._cache["polished_shapes"]
         if bits_prec <= curr_bits_prec:
             return [number(s) for s in pari_vector_to_list(curr_sol)]
 
     # Check and make sure initial solution is reasonable
 
-    if not ignore_solution_type and not manifold.solution_type() in ['all tetrahedra positively oriented' , 'contains negatively oriented tetrahedra']:
+    if not ignore_solution_type and manifold.solution_type() not in ['all tetrahedra positively oriented', 'contains negatively oriented tetrahedra']:
         raise ValueError('Initial solution to gluing equations has flat or degenerate tetrahedra')
 
-    init_shapes = pari_column_vector( [complex_to_pari(complex(z), working_prec) for z in manifold.tetrahedra_shapes('rect')] )
+    init_shapes = pari_column_vector([complex_to_pari(complex(z), working_prec) for z in manifold.tetrahedra_shapes('rect')])
     init_equations = manifold.gluing_equations('rect')
     if gluing_equation_error(init_equations, init_shapes) > pari(0.000001):
         raise ValueError('Initial solution not very good')
@@ -117,17 +136,17 @@ def polished_tetrahedra_shapes(manifold, dec_prec=None, bits_prec=200, ignore_so
     for i in range(100):
         errors = gluing_equation_errors(eqns, shapes)
         error = infinity_norm(errors)
-        if error < target_espilon or error > 100*initial_error:
+        if error < target_espilon or error > 100 * initial_error:
             break
-        derivative = pari_matrix( [ [  eqn[0][i]/z  - eqn[1][i]/(1 - z)  for i, z in enumerate(pari_vector_to_list(shapes))] for eqn in eqns] )
+        derivative = pari_matrix([[eqn[0][i] / z - eqn[1][i] / (1 - z)
+                                   for i, z in enumerate(pari_vector_to_list(shapes))] for eqn in eqns])
         gauss = derivative.matsolve(pari_column_vector(errors))
         shapes = shapes - gauss
 
     # Check to make sure things worked out ok.
     error = gluing_equation_error(init_equations, shapes)
     total_change = infinity_norm(init_shapes - shapes)
-    if error > 1000*target_espilon or total_change > pari(0.0000001):
+    if error > 1000 * target_espilon or total_change > pari(0.0000001):
         raise ValueError('Did not find a good solution to the gluing equations')
     manifold._cache["polished_shapes"] = (bits_prec, shapes)
     return [number(s) for s in pari_vector_to_list(shapes)]
-

snappy/snap/slice_obs_HKL.py

@@ -45,10 +45,8 @@ correct.
 
 from ..sage_helper import _within_sage, sage_method
 if _within_sage:
-    from sage.all import (ZZ, PolynomialRing, LaurentPolynomialRing,
-                          GF, QQ, CyclotomicField, vector, matrix,
-                          identity_matrix, block_matrix, diagonal_matrix,
-                          MatrixSpace, ChainComplex, prime_range)
+    from ..sage_helper import ZZ, PolynomialRing, vector, matrix, identity_matrix, MatrixSpace, block_matrix, prime_range, is_prime
+    from ..sage_helper import LaurentPolynomialRing, GF, CyclotomicField, ChainComplex
 
     from .nsagetools import (MapToFreeAbelianization, compute_torsion,
                              fox_derivative_with_involution,
@@ -59,6 +57,7 @@ if _within_sage:
 
 from .. import SnapPy
 
+
 class MatrixRepresentation():
     """
     A representation from a finitely-presented group to GL(n, R),
@@ -80,10 +79,10 @@ class MatrixRepresentation():
         if isinstance(matrices, dict):
             images = matrices
             all_gens = list(generators) + [g.swapcase() for g in generators]
-            assert set(matrices.keys()) == set(all_gens)
+            assert set(matrices) == set(all_gens)
         else:
             assert len(generators) == len(matrices)
-            images = dict()
+            images = {}
             for g, m in zip(generators, matrices):
                 images[g] = m
                 images[g.swapcase()] = image_ring(m.inverse())
@@ -122,7 +121,7 @@ class MatrixRepresentation():
         gens, rels, rho = self.generators, self.relators, self
         d2 = [ [fox_derivative_with_involution(R, rho, g) for R in rels] for g in gens]
         d2 = block_matrix(d2, nrows=len(gens), ncols=len(rels))
-        d1 = [rho(g.swapcase()) - 1  for g in gens]
+        d1 = [rho(g.swapcase()) - 1 for g in gens]
         d1 = block_matrix(d1, nrows=1, ncols=len(gens))
         C = ChainComplex({1:d1, 2:d2}, degree_of_differential=-1, check=True)
         return C
@@ -135,7 +134,7 @@ class MatrixRepresentation():
         gens, rels, rho = self.generators, self.relators, self
         d1 = [[fox_derivative(R, rho, g) for g in gens] for R in rels]
         d1 = block_matrix(d1, nrows=len(rels), ncols=len(gens))
-        d0 = [rho(g) - 1  for g in gens]
+        d0 = [rho(g) - 1 for g in gens]
         d0 = block_matrix(d0, nrow=len(gens), ncols=1)
         C = ChainComplex({0:d0, 1:d1}, check=True)
         return C
@@ -175,7 +174,7 @@ class MatrixRepresentation():
         target = MatrixSpace(rho.base_ring, n + 1)
         return MatrixRepresentation(gens, rels, target, new_mats)
 
-#----- end class MatrixRepresentation --------------------------------
+# ----- end class MatrixRepresentation --------------------------------
 
 
 def poly_to_rep(f):
@@ -184,7 +183,6 @@ def poly_to_rep(f):
     left action of x on F[x]/(f).
     """
     assert f.is_monic()
-    x = f.parent().gen()
     d = f.degree()
     last_column = [-f[e] for e in range(d)]
     I = identity_matrix(d)
@@ -240,6 +238,21 @@ def primes_appearing(knot_exterior, p):
     return sorted(primes)
 
 
+def nonzero_divisor_product(knot_exterior, p):
+    """
+       sage: M = Manifold('K12n731')
+       sage: nonzero_divisor_product(M, 3)
+       2704
+    """
+    C = knot_exterior.covers(p, cover_type='cyclic')[0]
+    divisors = C.homology().elementary_divisors()
+    ans = 1
+    for d in divisors:
+        if d != 0:
+            ans *= d
+    return ans
+
+
 def cyclic_rep(group, matrix_of_rep):
     """
     For a group G whose free abelianization is Z, returns the
@@ -332,7 +345,7 @@ def induced_rep_from_twisted_cocycle(p, rho, chi, cocycle):
     t = R.gen()
     MatSp = MatrixSpace(R, p)
     gens = rho.generators
-    images = dict()
+    images = {}
     for s, g in enumerate(gens):
         v = vector(cocycle[s*n:(s+1)*n])
         e = rho.epsilon(g)[0]
@@ -393,14 +406,14 @@ def twisted_alexander_polynomial(alpha, reduced=False):
     assert len(rels) == len(gens) - 1 and epsilon.range().rank() == 1
 
     # Want the first variable to be homologically nontrivial
-    i0 = [i for i, g in enumerate(gens) if epsilon(g) != 0][0]
+    i0 = next(i for i, g in enumerate(gens) if epsilon(g) != 0)
     gens = gens[i0:] + gens[:i0]
 
     # Boundary maps for chain complex
 
     d2 = [ [fox_derivative_with_involution(R, alpha, g) for R in rels] for g in gens]
     d2 = block_matrix(d2, nrows=k, ncols=k-1)
-    d1 = [alpha(g.swapcase())  - 1  for g in gens]
+    d1 = [alpha(g.swapcase()) - 1 for g in gens]
     d1 = block_matrix(d1, nrows=1, ncols=k)
     assert d1 * d2 == 0
 
@@ -463,7 +476,7 @@ def alex_poly_of_induced_rep(p, knot_exterior, A, chi):
     d0, d1 = C.differential(0), C.differential(1)
     B1 = d0.column_space()
     Z1 = d1.right_kernel()
-    cocycle = [z for z in Z1.basis() if not z in B1][0]
+    cocycle = next(z for z in Z1.basis() if z not in B1)
     alpha = induced_rep_from_twisted_cocycle(p, rho, chi, cocycle)
     ans = twisted_alexander_polynomial(alpha, reduced=True)
     assert poly_involution(ans) == ans
@@ -532,6 +545,8 @@ def slicing_is_obstructed(knot_exterior, p, q):
        sage: slicing_is_obstructed(M, 3, 7)
        True
     """
+    p, q = ZZ(p), ZZ(q)
+    assert is_prime(p) and is_prime(q) and q > 2
     reps = list(reps_appearing(knot_exterior, p, q))
     if len(reps) == 0:
         return False
@@ -548,6 +563,17 @@ def slicing_is_obstructed(knot_exterior, p, q):
     return True
 
 
+def expand_prime_spec(spec, min_prime=2):
+    if spec in ZZ:
+        a, b = 0, spec
+    else:
+        if len(spec) != 2:
+            raise ValueError(f'Spec {spec} does not specify a range')
+        a, b = spec
+    a = max(a, min_prime)
+    return prime_range(a, b + 1)
+
+
 @sage_method
 def slice_obstruction_HKL(self, primes_spec,
                           verbose=False, check_in_S3=True):
@@ -570,7 +596,14 @@ def slice_obstruction_HKL(self, primes_spec,
        sage: spec = [(10, [0, 20]), (20, [0, 10])]
        sage: M.slice_obstruction_HKL(spec, verbose=True)
           Looking at (2, 3) ...
-          Looking at (3, 2) ...
+          Looking at (3, 7) ...
+       (3, 7)
+
+    You can also specify the p to examine by a range [p_min, p_max] or
+    the q by just q_max::
+
+       sage: spec = [([3, 10], 10)]
+       sage: M.slice_obstruction_HKL(spec, verbose=True)
           Looking at (3, 7) ...
        (3, 7)
 
@@ -604,22 +637,28 @@ def slice_obstruction_HKL(self, primes_spec,
     if len(primes_spec) == 2:
         p, q = primes_spec
         if p in ZZ and q in ZZ:
+            if q == 2:
+                raise ValueError('Must have q > 2 when looking at H_1(cover; F_q)')
+            if not (is_prime(p) and is_prime(q)):
+                raise ValueError('Both p and q must be prime')
             if slicing_is_obstructed(M, p, q):
                 return (p, q)
             else:
                 return None
 
     # Main case
-    primes_spec = sorted(primes_spec)
-    p_max = primes_spec[-1][0]
-    for p in prime_range(1, p_max + 1):
-        q_min, q_max = [q for a, q in primes_spec if p <= a][0]
-        for q in primes_appearing(M, p):
-            if q_min <= q <= q_max:
-                if verbose:
-                    print('   Looking at', (p, q), '...')
-                if slicing_is_obstructed(M, p, q):
-                    return (p, q)
+    primes_spec = [(expand_prime_spec(a), expand_prime_spec(b, min_prime=3))
+                   for a, b in primes_spec]
+    for ps, qs in primes_spec:
+        for p in ps:
+            d = nonzero_divisor_product(M, p)
+            for q in qs:
+                if d % q == 0:
+                    if verbose:
+                        print('   Looking at', (p, q), '...')
+                    if slicing_is_obstructed(M, p, q):
+                        return (p, q)
+
 
 if __name__ == '__main__':
     import doctest

snappy/snap/t3mlite/arrow.py

@@ -1,13 +1,13 @@
-#$Id: arrow.py,v 1.3 2003/04/30 19:59:58 t3m Exp $
+# $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 
+#   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 .tetrahedron 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
@@ -34,6 +34,39 @@ from .tetrahedron import *
 # 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):
@@ -42,8 +75,8 @@ class Arrow:
         self.Tetrahedron = tet
 
     def __repr__(self):
-        return ('< '+SubsimplexName[self.Edge]+' | '+
-                SubsimplexName[self.Face]+' | '+str(self.Tetrahedron)+' >') 
+        return ('< '+SubsimplexName[self.Edge]+' | ' +
+                SubsimplexName[self.Face]+' | '+str(self.Tetrahedron)+' >')
 
     def head(self):
         return self.Face & comp(self.Edge)
@@ -72,16 +105,14 @@ class Arrow:
         return self.Tetrahedron.Class[self.tail() | OppTail[self.tail(),self.head()]]
 
     def is_null(self):
-        if self.Tetrahedron is None:
-            return 1
-        return 0
+        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)
+        self.Face = flip_face[self.Edge, self.Face]
         return self
 
 # By successive applications of self.next() you can walk around an edge.
@@ -90,76 +121,87 @@ class Arrow:
 # When you hit the boundary, self.next() returns None without changing self.
 # Does NOT create a new arrow.
     def next(self):
-        if not self.Tetrahedron == None:
+        if self.Tetrahedron is not None:
             perm = self.Tetrahedron.Gluing[self.Face]
             tet = self.Tetrahedron.Neighbor[self.Face]
-        if tet == None:
+        if tet is None:
             return None
-        self.Edge = perm.image(self.Edge)
-        self.Face = flip_face(self.Edge, perm.image(self.Face))
+
+        # 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 == None and other.Tetrahedron == None:
+    def glue(self, other):
+        if self.Tetrahedron is None and other.Tetrahedron is None:
             return
-        if self.Tetrahedron == None:
+        if self.Tetrahedron is None:
             other.reverse().glue(self)
             other.reverse()
             return
-        if other.Tetrahedron == None: 
+        if other.Tetrahedron is None:
             self.Tetrahedron.attach(self.Face, None, (0,1,2,3))
             return
-        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] })
-
-# Returns a COPY of self.next(), or a null arrow in the case of a boundary
-# face.
-# DOES create a new arrow.
+        # 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() == None:
+        if a.next() is None:
             a.Tetrahedron = None
         return a
 
-# Changes the arrow into its opposite.
-# Does NOT create a new arrow.
+    # Changes the arrow into its opposite.
+    # Does NOT create a new arrow.
     def opposite(self):
-        self.Face = comp(OppTail[(self.tail(),self.head())])
-        self.Edge = comp(self.Edge)
+        # 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):
+    # 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.Edge = tail | OppTail[(tail, head)]
             self.Face = self.Edge | head
         return self
 
-# DOES create a new arrow.
+    # 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.
-
+    # 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 == None:
+        if other is None:
             return False
-        if self.Tetrahedron == None and other.Tetrahedron == None:
+        if self.Tetrahedron is None and other.Tetrahedron is None:
             return True
-        if (self.Tetrahedron == other.Tetrahedron and
+        return (self.Tetrahedron == other.Tetrahedron and
             self.Edge == other.Edge and
-                self.Face == other.Face):
-            return True
-        return False
+            self.Face == other.Face)
 
     def __ne__(self, other):
         return not self.__eq__(other)
@@ -199,8 +241,3 @@ class eArrow(Arrow):
         self.Edge = comp( tail | head )
         self.Face = comp( tail )
         self.Tetrahedron = tet
-
-
-
-
-

snappy/snap/t3mlite/corner.py

@@ -1,16 +1,16 @@
-#$Id: corner.py,v 1.2 2002/09/20 03:52:16 culler Exp $
+# $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 
+#   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 .tetrahedron import *
+from .simplex import SubsimplexName
 
 # A Corner is a "subsimplex in a tetrahedron".
 
+
 class Corner:
 
     def __init__(self, tetrahedron, subsimplex):
@@ -18,6 +18,5 @@ class Corner:
         self.Subsimplex = subsimplex
 
     def __repr__(self):
-        return ('<'+SubsimplexName[self.Subsimplex]+ ' of '+ 
+        return ('<'+SubsimplexName[self.Subsimplex] + ' of ' +
                 str(self.Tetrahedron) + '>')
-