snappy 3.2__cp313-cp313-macosx_11_0_arm64.whl

snappy/snap/t3mlite/tetrahedron.py

@@ -0,0 +1,109 @@
+# $Id: tetrahedron.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 *
+from .perm4 import Perm4, inv
+
+import sys
+
+
+class Tetrahedron:
+    def __init__(self, name=''):
+        self.Index = -1
+        self.Name = name
+        self.Neighbor = {F0:None,F1:None,F2:None,F3:None}  # Tetrahedra
+        self.Gluing = {F0:None,F1:None,F2:None,F3:None}  # Permutations
+        self.Class = [None]*16             # list of equivalence classes
+        self.Checked = 0                     # flag
+
+    def __repr__(self):
+        if self.Index != -1:
+            return ( 'tet' + str(self.Index) )
+        else:
+            return '< floating tetrahedron ' + ' at ' + str(id(self)) + '>'
+
+    def attach(self, two_subsimplex, tet, perm_data):
+        if tet is None:
+            self.Neighbor[two_subsimplex] = None
+            self.Gluing[two_subsimplex] = None
+        else:
+            perm = Perm4(perm_data)
+            self.Neighbor[two_subsimplex] = tet
+            self.Gluing[two_subsimplex] = perm
+            tet.Neighbor[perm.image(two_subsimplex)] = self
+            tet.Gluing[perm.image(two_subsimplex)] = inv(self.Gluing[two_subsimplex])
+
+    # Reverse the orientation.  Vertices are relabelled by a transposition
+    # and gluings are adjusted.
+    def reverse(self):
+        transpo = Perm4((1, 0, 2, 3))
+        nhbr = self.Neighbor.copy()
+        gluing = self.Gluing.copy()
+        for two_subsimplex in TwoSubsimplices:
+            relabeled = transpo.image(two_subsimplex)
+            if nhbr[two_subsimplex] is not None:
+                perm = (gluing[two_subsimplex] * transpo).tuple()
+            else:
+                perm = None
+            self.attach(relabeled, nhbr[two_subsimplex], perm)
+
+    # Unglues and removes references to self from neighbor.
+    def detach(self, two_subsimplex):
+        neighbor = self.Neighbor[two_subsimplex]
+        if neighbor is None:
+            return
+        neighbors_subsimplex = self.Gluing[two_subsimplex].image(two_subsimplex)
+        self.Neighbor[two_subsimplex] = None
+        self.Gluing[two_subsimplex] = None
+        if (neighbor.Neighbor and
+                neighbor.Neighbor[neighbors_subsimplex] == self):
+            neighbor.Neighbor[neighbors_subsimplex] = None
+            neighbor.Gluing[neighbors_subsimplex] = None
+
+    def erase(self):
+        for two_subsimplex in TwoSubsimplices:
+            self.detach(two_subsimplex)
+        self.Index = -1
+        self.Neighbor = None
+        self.Gluing = None
+        self.clear_Class()
+
+    def clear_Class(self):
+        self.Class = [None]*16              # list of equivalence classes
+
+    def info(self, out=sys.stdout):
+        if len(self.Name) == 0:
+            out.write(repr(self) + "\t%s\n" %
+                      ([self.Neighbor.get(s) for s in TwoSubsimplices]))
+        else:
+            out.write(repr(self) + " ( " + self.Name + " )\n")
+            out.write("\t%s\n" % ([self.Neighbor.get(s) for s in TwoSubsimplices]))
+
+        out.write("\t%s\n" % ([self.Gluing.get(s) for s in TwoSubsimplices]))
+
+        out.write("\tVertices: " + repr(self.Class[V0])
+                                 + repr(self.Class[V1])
+                                 + repr(self.Class[V2])
+                                 + repr(self.Class[V3]) + '\n')
+
+        if self.Index > -1:
+            s = ""
+            for edge in OneSubsimplices[:3]:
+                s = (s + "%s : %-10s   " %
+                     (SubsimplexName[edge], self.Class[edge]))
+            out.write("\tEdges: " + s + '\n')
+            s = ""
+            for edge in OneSubsimplices[3:]:
+                s = (s + "%s : %-10s   " %
+                     (SubsimplexName[edge], self.Class[edge]))
+            out.write("\t       " + s + '\n')
+
+    # Below added 7/12/99 by NMD
+
+    def get_orientation_of_edge(self, a, b):
+        return self.Class[a | b].orientation_with_respect_to(self, a, b)

snappy/snap/t3mlite/vertex.py

@@ -0,0 +1,42 @@
+# $Id: vertex.py,v 1.3 2003/03/07 17:29:28 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.
+
+class Vertex:
+    def __init__(self):
+        self.Index = -1
+        self.IntOrBdry = ''
+        self.Corners = []      # Corners of type "0-simplex in Tetrahedron"
+        self.Edges = []        # incident Edges
+        # An Edge will appear twice if both its endpoints
+        # are equal to this Vertex
+
+    def __repr__(self):
+        if self.Index > -1:
+            return ('v' + str(self.Index)
+                    + ' (' + self.IntOrBdry + ') ')
+        else:
+            return '< floating vertex' + str(id(self)) + ' >'
+
+    def erase(self):
+        for corner in self.Corners:
+            corner.Tetrahedron.Class[corner.Subsimplex] = None
+        for edge in self.Edges:
+            try:
+                edge.Vertices.remove(self)
+            except:
+                pass
+        self.Index = -1
+
+    def link_genus(self):
+        # The link of a vertex in an Mcomplex is a surface
+        # of arbitrary genus, possibly with non-empty boundary.
+        # For now I am pretending that links are closed and orientable
+        sum = 12
+        for edge in self.Edges:
+            sum = sum - 6 + edge.valence()
+        return sum//12

snappy/snap/test.py

@@ -0,0 +1,134 @@
+from snappy import testing
+import snappy
+
+from snappy.sage_helper import _within_sage
+from snappy.pari import pari
+
+from snappy import snap
+
+modules = [
+    snap,
+    snap.t3mlite.linalg,
+    snap.t3mlite.mcomplex,
+    snap.t3mlite.perm4,
+    snap.t3mlite.spun,
+    snap.character_varieties,
+    snap.slice_obs_HKL,
+    snap.nsagetools,
+    snap.polished_reps,
+    snap.interval_reps,
+    snap.fundamental_polyhedron,
+    snap.peripheral.dual_cellulation,
+    snap.peripheral.link,
+    snap.peripheral.peripheral
+]
+
+def run_doctests(verbose=False, print_info=True):
+    globs = {'Manifold':snappy.Manifold,
+             'ManifoldHP':snappy.ManifoldHP,
+             'Triangulation':snappy.Triangulation,
+             'Mcomplex':snappy.snap.t3mlite.Mcomplex,
+             'LinkSurface':snappy.snap.peripheral.link.LinkSurface}
+    return testing.doctest_modules(modules,
+                                   verbose=verbose,
+                                   print_info=print_info,
+                                   extraglobs=globs)
+
+run_doctests.__name__ = snap.__name__
+
+def _test_gluing_equations(manifold, shapes):
+    """
+    Given a manifold and exact shapes, test whether the rectangular gluing
+    equations are fulfilled.
+    """
+    one_minus_shapes = [1 - shape for shape in shapes]
+    for A, B, c in manifold.gluing_equations('rect'):
+        val = c
+        for a, shape in zip(A, shapes):
+            val *= shape ** a
+        for b, one_minus_shape in zip(B, one_minus_shapes):
+            val *= one_minus_shape ** b
+        if not val == 1:
+            return False
+    return True
+
+
+def test_polished(dec_prec=200):
+    def test_manifold(manifold):
+        eqns = manifold.gluing_equations('rect')
+        shapes = manifold.tetrahedra_shapes('rect', dec_prec=dec_prec)
+        return snap.shapes.gluing_equation_error(eqns, shapes)
+
+    def test_census(name, census):
+        manifolds = list(census)
+        print('Checking gluing equations for %d %s manifolds' % (len(manifolds), name))
+        max_error = pari(0)
+        for i, M in enumerate(manifolds):
+            max_error = max(max_error, test_manifold(M))
+            print('\r   ' + repr( (i, M) ).ljust(35) + '   Max error so far: %.2g' % float(max_error), end='')
+        print()
+
+    test_census('cusped census', snappy.OrientableCuspedCensus(filter='cusps>1')[-100:])
+    test_census('closed census', snappy.OrientableClosedCensus()[-100:])
+    test_census('4-component links', [M for M in snappy.LinkExteriors(num_cusps=4) if M.solution_type() == 'all tetrahedra positively oriented'])
+
+
+def test_holonomy(dec_prec=200):
+    def test_manifold(manifold):
+        # This has several internal checks which raise exceptions
+        # if something is amiss
+        G = snap.polished_holonomy(manifold, dec_prec=dec_prec)
+
+    for census in [snappy.OrientableCuspedCensus, snappy.OrientableClosedCensus]:
+        print('Testing holonomy of 100 manifolds in ', census)
+        for manifold in census()[-100:]:
+            test_manifold(manifold)
+
+
+def test_fields(bits_prec=200, degree=20):
+    for census in [snappy.OrientableCuspedCensus, snappy.OrientableClosedCensus]:
+        print('Fields of 100 manifolds in ', census)
+        for manifold in census()[:100]:
+            S = snap.tetrahedra_field_gens(manifold)
+            Tr = snap.trace_field_gens(manifold)
+            InvTr = snap.trace_field_gens(manifold)
+            hol = snap.holonomy_matrix_entries(manifold)
+            for kind, X in [('shapes', S),
+                            ('trace', Tr),
+                            ('invtrace', InvTr),
+                            ('hol', hol)]:
+                K = X.find_field(bits_prec, degree)
+                if K is None:
+                    print('Problem with', manifold, kind)
+                else:
+                    if kind == 'shapes':
+                        # Field is a sage number field, shapes are polynomials
+                        field, numerical_root, shapes = K
+                        # Turn the polynomials expressing the shapes in the
+                        # root of the number field into expressions in the
+                        # number field
+                        shapes = [ field(shape) for shape in shapes ]
+                        if not _test_gluing_equations(manifold, shapes):
+                            print('Problem with', manifold,
+                                  '(gluing equations violated)')
+
+
+def test_ZHS(bits_prec=500, degree=20):
+    for manifold in snappy.OrientableClosedCensus:
+        if manifold.homology().order() == 1:
+            T = snap.trace_field_gens(manifold)
+            ans = T.find_field(bits_prec, degree, True)
+            if ans:
+                print(manifold, ans[0].polynomial())
+            else:
+                print(manifold, ans)
+
+
+def big_test():
+    test_polished()
+    if _within_sage:
+        test_holonomy()
+        test_fields()
+
+if __name__ == '__main__':
+    testing.run_doctests_as_main(run_doctests)

snappy/snap/utilities.py

@@ -0,0 +1,288 @@
+"""A collection of Python classes and objects which emulate various
+features of Sage; the purpose of these is to allow some of the
+snappy.snap tools to be used in an environment where Sage is not
+available, such as in the SnapPy GUI or in a Windows python
+interpreter.
+
+"""
+
+from ..sage_helper import _within_sage
+from snappy.number import SnapPyNumbers, Number
+from itertools import chain
+from ..pari import pari, PariError
+from .fundamental_polyhedron import Infinity
+if _within_sage:
+    from ..sage_helper import matrix as sage_matrix, vector as sage_vector
+    from ..sage_helper import RealField_class, ComplexField_class
+
+    def is_field(R):
+        return isinstance(R, (SnapPyNumbers, RealField_class,
+                              ComplexField_class))
+else:
+    def is_field(R):
+        return isinstance(R, SnapPyNumbers)
+
+
+class MatrixBase():
+    """Base class for Vector2 and Matrix2x2. Do not instantiate."""
+    _base_ring = None
+
+    def __len__(self):
+        return 2
+
+    def _pari_(self):
+        # force left multiplication by Numbers to use rmul
+        raise PariError
+
+    def base_ring(self):
+        """If a base ring was set when initializing the matrix, then this
+        method will return that ring.  Otherwise, the base ring is a
+        SnapPyNumbers object whose precision is the maximum precision
+        of the elements.  If a new Number is created using the computed
+        base ring and combined with the entries of this matrix, then the
+        precision of the result will be determined by the precisions of
+        the entries.
+        """
+        if self._base_ring:
+            return self._base_ring
+        else:
+            precision = max([x.prec() for x in self.list()])
+            return SnapPyNumbers(precision=precision)
+
+    def list(self):
+        # Override this
+        return []
+
+
+class Vector2(MatrixBase):
+    """A 2-dimensional vector whose entries are snappy Numbers."""
+    def __init__(self, *args):
+        if is_field(args[0]):
+            self._base_ring = number = SnapPyNumbers(args[0].precision())
+            args = args[1:]
+        else:
+            self._base_ring = None
+            number = Number
+        if len(args) == 1:
+            args = args[0]
+        if len(args) == 2:
+            self.x, self.y = (number(t) for t in args)
+        else:
+            raise ValueError('Invalid initialization for a Vector2.')
+
+    def __getitem__(self, index):
+        if index == 0:
+            return self.x
+        elif index == 1:
+            return self.y
+        else:
+            raise IndexError('Invalid Vector2 index.')
+
+    def __repr__(self):
+        entries = [str(e) for e in self.list()]
+        size = max(map(len, entries))
+        entries = tuple(('%%-%d.%ds' % (size, size)) % x for x in entries)
+        return '[ %s ]\n[ %s ]' % entries
+
+    def __add__(self, other):
+        return Vector2(self.x + other.x, self.y + other.y)
+
+    def __sub__(self, other):
+        return Vector2(self.x - other.x, self.y - other.y)
+
+    def __mul__(self, other):
+        if isinstance(other, Matrix2x2):
+            return Vector2(self.x * other.a + self.y * other.c,
+                           self.x * other.b + self.y * other.d)
+        if isinstance(other, Number):
+            return Vector2(self.x * other, self.y * other)
+        try:
+            return self * self.base_ring()(other)
+        except (TypeError, ValueError):
+            return NotImplemented
+
+    def __rmul__(self, other):
+        return Vector2(self.x * other, self.y * other)
+
+    def __div__(self, other):
+        return Vector2(self.x / other, self.y / other)
+
+    def __truediv__(self, other):
+        return Vector2(self.x / other, self.y / other)
+
+    def __neg__(self):
+        return Vector2(-self.x, -self.y)
+
+    def list(self):
+        return [self.x, self.y]
+
+    def sage(self):
+        return sage_vector([self.x.sage(), self.y.sage()])
+
+    def norm(self, p=2):
+        if p == 1:
+            return self.x.abs() + self.y.abs()
+        if p == 2:
+            return ((self.x * self.x).abs() + (self.y * self.y).abs()).sqrt()
+        if p == Infinity:
+            return max(self.x.abs(), self.y.abs())
+
+
+class Matrix2x2(MatrixBase):
+    """A 2x2 matrix class whose entries are snappy Numbers."""
+    def __init__(self, *args):
+        if is_field(args[0]):
+            self._base_ring = number = SnapPyNumbers(args[0].precision())
+            args = args[1:]
+        else:
+            self._base_ring = None
+            number = Number
+        if len(args) == 1:
+            args = tuple(chain(*args[0]))
+        if len(args) == 4:
+            self.a, self.b, self.c, self.d = (number(x) for x in args)
+        else:
+            raise ValueError('Invalid initialization for a Matrix2x2.')
+
+    def __repr__(self):
+        entries = [str(e) for e in self.list()]
+        size = max(map(len, entries))
+        entries = tuple(('%%-%d.%ds' % (size, size)) % x for x in entries)
+        return '[ %s  %s ]\n[ %s  %s ]' % entries
+
+    def __getitem__(self, index):
+        if isinstance(index, int):
+            if index == 0:
+                return [self.a, self.b]
+            if index == 1:
+                return [self.c, self.d]
+        elif isinstance(index, tuple) and len(index) == 2:
+            i, j = index
+            if i == 0:
+                return self.a if j == 0 else self.b
+            if i == 1:
+                return self.c if j == 0 else self.d
+        raise IndexError('Invalid 2x2 matrix index.')
+
+    def __add__(self, other):
+        return Matrix2x2(self.a + other.a,
+                         self.b + other.b,
+                         self.c + other.c,
+                         self.d + other.d)
+
+    def __sub__(self, other):
+        return Matrix2x2(self.a - other.a,
+                         self.b - other.b,
+                         self.c - other.c,
+                         self.d - other.d)
+
+    def __mul__(self, other):
+        if isinstance(other, Matrix2x2):
+            return Matrix2x2(self.a * other.a + self.b * other.c,
+                             self.a * other.b + self.b * other.d,
+                             self.c * other.a + self.d * other.c,
+                             self.c * other.b + self.d * other.d)
+        if isinstance(other, Vector2):
+            return Vector2(self.a * other.x + self.b * other.y,
+                           self.c * other.x + self.d * other.y)
+        if isinstance(other, Number):
+            return Matrix2x2(self.a * other, self.b * other,
+                             self.c * other, self.d * other)
+        try:
+            return self * self.base_ring()(other)
+        except (TypeError, ValueError):
+            return NotImplemented
+
+    def __rmul__(self, other):
+        # Assumes that other is a scalar. This will not be
+        # called when left multiplying by a Matrix2x2
+        return Matrix2x2(self.a * other, self.b * other,
+                         self.c * other, self.d * other)
+
+    def __div__(self, other):
+        # Assumes that other is a scalar.
+        return Matrix2x2(self.a / other, self.b / other,
+                         self.c / other, self.d / other)
+
+    def __truediv__(self, other):
+        # Assumes that other is a scalar.
+        return Matrix2x2(self.a / other, self.b / other,
+                         self.c / other, self.d / other)
+
+    def __neg__(self):
+        return Matrix2x2(-self.a, -self.b, -self.c, -self.d)
+
+    def __invert__(self):
+        try:
+            D = 1 / self.det()
+        except ZeroDivisionError:
+            raise ZeroDivisionError('matrix %s is not invertible.' % self)
+        return Matrix2x2(self.d * D, -self.b * D, -self.c * D, self.a * D)
+
+    def adjoint(self):
+        return Matrix2x2(self.d, -self.b, -self.c, self.a)
+
+    def determinant(self):
+        return self.a * self.d - self.b * self.c
+
+    det = determinant
+
+    def trace(self):
+        return self.a + self.d
+
+    def eigenvalues(self):
+        # WARNING: This can take infinitely long!!!! (WHY???)
+        R = self.base_ring()
+        x = pari('x')
+        a, b, c, d = map(pari, self.list())
+        p = x * x - (a + d) * x + (a * d - b * c)
+        roots = p.polroots(precision=R.precision())
+        return map(R, roots)
+
+    def norm(self, p=2):
+        if p == 1:
+            return max(self.a.abs() + self.c.abs(), self.b.abs() + self.d.abs())
+        if p == 'frob':
+            return sum([x * x for x in self.list()]).sqrt()
+        if p == Infinity:
+            return max(self.a.abs() + self.b.abs(), self.c.abs() + self.d.abs())
+        if p == 2:
+            return max([x.abs() for x in self.eigenvalues()])
+
+    def list(self):
+        return [self.a, self.b, self.c, self.d]
+
+    def rows(self):
+        return [Vector2(self.base_ring(), self.a, self.b),
+                Vector2(self.base_ring(), self.a, self.b)]
+
+    def sage(self):
+        return sage_matrix(2, 2, [x.sage() for x in self.list()])
+
+
+def indexset(n):
+    """The orders of the non-zero bits in the binary expansion of n."""
+    i = 0
+    result = []
+    while True:
+        mask = 1 << i
+        if n & mask:
+            result.append(i)
+        if n < mask:
+            break
+        i += 1
+    return result
+
+
+def powerset(X):
+    """Iterator for all finite subsequences of the iterable X"""
+    n = 0
+    segment = []
+    for x in X:
+        segment.append(x)
+        while True:
+            try:
+                yield [segment[i] for i in indexset(n)]
+            except IndexError:
+                break
+            n += 1