snappy 3.2__cp311-cp311-macosx_10_12_x86_64.whl

snappy/twister/surfaces/S_0_4_Lantern

@@ -0,0 +1,8 @@
+# A Twister surface file
+# To test the lantern relation, check that C*A*B is trivial.
+annulus,a,A,+0,-8,+5,-9,-3,-2#
+annulus,b,B,+1,-6,+3,-10,-4,-0#
+annulus,c,C,+2,-7,+4,-11,-5,-1#
+rectangle,x,X,+7,+10#
+rectangle,y,Y,+8,+11#
+rectangle,z,Z,+6,+9#

snappy/twister/surfaces/S_1

@@ -0,0 +1,3 @@
+# A Twister surface file
+annulus,a,A,+0#
+annulus,b,B,-0#

snappy/twister/surfaces/S_1_1

@@ -0,0 +1,4 @@
+# A Twister surface file
+annulus,a,A,+0,-1#
+annulus,b,B,-0#
+rectangle,x,X,+1#

snappy/twister/surfaces/S_1_2

@@ -0,0 +1,5 @@
+# A Twister surface file
+annulus,a,A,+0#
+annulus,b,B,-0,+1#
+annulus,c,C,-1,+2#
+rectangle,x,X,-2#

snappy/twister/surfaces/S_1_2_5

@@ -0,0 +1,6 @@
+# A Twister surface file
+annulus,a,A,+0,+3#
+annulus,b,B,-0,+1#
+annulus,c,C,-1,+2#
+rectangle,x,X,-2#
+rectangle,y,Y,-3# 

snappy/twister/surfaces/S_2

@@ -0,0 +1,6 @@
+# A Twister surface file
+annulus,a,A,+0#
+annulus,b,B,-0,+1#
+annulus,c,C,-1,+2#
+annulus,d,D,-2,+3# 
+annulus,e,E,-3#

snappy/twister/surfaces/S_2_1

@@ -0,0 +1,8 @@
+# A Twister surface file
+annulus,a,A,-0,+1#
+annulus,b,B,-1,+2#
+annulus,c,C,-2,+3,+4,+5#
+annulus,d,D,-3#
+annulus,e,E,-5#
+annulus,f,F,+0#
+rectangle,x,X,-4#

snappy/twister/surfaces/S_2_heeg

@@ -0,0 +1,10 @@
+# A Twister surface file
+#
+# After adding handles a*b*C*D the curve e is the figure eight knot on
+# the standard genus two splitting of S3.
+#
+annulus,a,A,-0,-2,+5#
+annulus,b,B,-1,+8,-3#
+annulus,c,C,+0,-6,+9#
+annulus,d,D,+1,+7,-4#
+annulus,e,E,+2,+3,+4,-5,+6,-7,-8,-9#

snappy/twister/surfaces/S_3

@@ -0,0 +1,8 @@
+# A Twister surface file
+annulus,a,A,+0#
+annulus,b,B,-0,+1#
+annulus,c,C,-1,+2,+5#
+annulus,d,D,-2,+3#
+annulus,e,E,-3,+4#
+annulus,f,F,-4#
+annulus,g,G,-5#

snappy/twister/surfaces/S_3_1

@@ -0,0 +1,10 @@
+# A Twister surface file
+annulus,a,A,+7#
+annulus,b,B,-7,+6#
+annulus,c,C,-0,-6,+1#
+annulus,d,D,-1,+2#
+annulus,e,E,-2,+3,+4,+5#
+annulus,f,F,-3#
+annulus,g,G,-5#
+annulus,h,H,+0#
+rectangle,x,X,-4#

snappy/twister/surfaces/S_4_1

@@ -0,0 +1,12 @@
+# A Twister surface file
+annulus,a,A,+9#
+annulus,b,B,+8,-9#
+annulus,c,C,+7,-8#
+annulus,d,D,-7,+6#
+annulus,e,E,-0,-6,+1#
+annulus,f,F,-1,+2#
+annulus,g,G,-2,+3,+4,+5#
+annulus,h,H,-3#
+annulus,i,I,-5#
+annulus,j,J,+0#
+rectangle,x,X,-4#

snappy/twister/surfaces/S_5_1

@@ -0,0 +1,14 @@
+# A Twister surface file
+annulus,a,A,+11#
+annulus,b,B,+10,-11#
+annulus,c,C,+9,-10#
+annulus,d,D,+8,-9#
+annulus,e,E,+7,-8#
+annulus,f,F,-7,+6#
+annulus,g,G,-0,-6,+1#
+annulus,h,H,-1,+2#
+annulus,i,I,-2,+3,+4,+5#
+annulus,j,J,-3#
+annulus,k,K,-5#
+annulus,l,L,+0#
+rectangle,x,X,-4#

snappy/twister/surfaces/heeg_fig8

@@ -0,0 +1,9 @@
+# A Twister surface file
+#
+# Attaching handles a*b*C gives the handlebody/compression body
+# decomposition of the figure eight knot complement.
+#
+annulus,a,A,+0,-1,+2,-3,+4#
+annulus,b,B,-5,+6,-7,+8,-9#
+annulus,c,C,-0,+7,-4,-6,+1,+9,-2,+5,+3,-8#
+macro,h,a*b*C#

snappy/upper_halfspace/__init__.py

@@ -0,0 +1,146 @@
+from ..matrix import make_matrix
+from ..sage_helper import _within_sage
+from ..exceptions import InsufficientPrecisionError
+from ..math_basics import is_ComplexIntervalFieldElement
+
+"""
+
+upper_halfspace contains methods relating to the upper halfspace model
+
+                 H^3 = { w = z + ti : t > 0 }
+
+with a PSL(2,C)-matrix m = [[a,b],[c,d]] acting as
+
+           w |-> (a * w + b)^-1 * (c * w + d)
+
+It also contains methods converting from the upper halfspace model to
+other models of hyperbolic space including the conversion psl2c_to_o13.
+
+Points on the boundary C union {infty} of H^3 can be stored by either
+assigning a complex number or the sentinel
+upper_halfspace.ideal_point.Infinity to a variable. Functions using this
+representations of the boundary of H^3 are in ideal_point.
+
+Conventions:
+
+A SL(2,C)-matrix is a matrix constructed by snappy.matrix.matrix(...)
+(that is either snappy's own SimpleMatrix or a SageMath matrix type)
+with base_ring being a complex type (either a SnapPy.Number or one
+of SageMath's complex types including ComplexIntervalField, but not
+python's native complex type, e.g., 1 + 1j) and determinant being one.
+
+psl2c in a function name indicates that the function takes an SL(2,C)-matrix
+and the result (at least up rounding errors) does change when multiplying
+by -1.
+
+pgl2c in a function name indicates that the function takes any non-degenerate
+complex 2x2-matrix and uses the isomorphism PGL(2,C)=PSL(2,C).
+"""
+
+
+def sl2c_inverse(A):
+    return make_matrix([[A[1,1], -A[0, 1]], [-A[1, 0], A[0, 0]]])
+
+
+def psl2c_to_o13(A):
+    """
+    Converts matrix in PSL(2,C) to O13.
+
+    Python implementation of Moebius_to_O31 in matrix_conversion.c.
+    """
+
+    Aadj = _adjoint(A)
+
+    return make_matrix(
+        [ _o13_matrix_column(A, m, Aadj)
+          for m in _basis_vectors_sl2c(A.base_ring()) ]).transpose()
+
+
+def pgl2c_to_o13(m):
+    """
+    Converts matrix in PGL(2,C) to O13.
+
+    Python implementation of Moebius_to_O31 in matrix_conversion.c.
+    """
+    return psl2c_to_o13(m / m.det().sqrt())
+
+def complex_length_of_psl2c_matrix(m):
+    """
+    Complex length of translation corresponding to given PSL(2,C)
+    matrix.
+
+    Note that there is a branch cut here and we need to pick between
+    +/- 2 * arccosh(trace / 2).
+
+    We pick the cut with non-negative real part.
+
+    For non-verified computations, the real part will be non-negative.
+
+    For verified computations, the real part of the interval will contain
+    the non-negative real length. If the real length is very close to zero,
+    the real part of the interval might contain negative numbers as well.
+    """
+
+    tr = m.trace()
+    if not tr.real() >= 0:
+        # SageMath's arccosh has a branch cut on (-inf, -1].
+        #
+        # Ideally, the complex interval version would make a choice when
+        # we cross the branch cut (like it does for log).
+        #
+        # However, it returns (-pi, pi) as imaginary part when we cross
+        # branch cut.
+        #
+        # So flip trace to avoid the branch cut.
+
+        tr = -tr
+
+    l = 2 * _arccosh(tr / 2)
+
+    # The result it +/-l. But which one is it?
+
+    if l.real() >= 0:
+        # It is unambiguous.
+        return  l
+    if l.real() <= 0:
+        # It is unambiguous.
+        return -l
+
+    if is_ComplexIntervalFieldElement(l):
+        # It is ambiguous. Be conversative and take both.
+        return l.union(-l)
+
+    raise InsufficientPrecisionError(
+        "Encountered NaN when computing complex length of "
+        "matrix.\n"
+        "Trace: %r\n"
+        "Try increasing precision" % tr)
+
+def _basis_vectors_sl2c(CF):
+    return [ make_matrix([[ 1 , 0 ],
+                          [ 0, 1 ]], ring=CF),
+             make_matrix([[ 1 , 0 ],
+                          [ 0 ,-1 ]], ring=CF),
+             make_matrix([[ 0 , 1 ],
+                          [ 1 , 0 ]], ring=CF),
+             make_matrix([[ 0 , 1j],
+                          [-1j, 0 ]], ring=CF) ]
+
+def _adjoint(m):
+    return make_matrix([[ m[0][0].conjugate(), m[1][0].conjugate()],
+                        [ m[0][1].conjugate(), m[1][1].conjugate()]])
+
+
+def _o13_matrix_column(A, m, Aadj):
+    fAmj = A * m * Aadj
+
+    return [ (fAmj[0][0].real() + fAmj[1][1].real()) / 2,
+             (fAmj[0][0].real() - fAmj[1][1].real()) / 2,
+              fAmj[0][1].real(),
+              fAmj[0][1].imag() ]
+
+if _within_sage:
+    from ..sage_helper import arccosh as _arccosh
+else:
+    def _arccosh(z):
+        return z.arccosh()

snappy/upper_halfspace/ideal_point.py

@@ -0,0 +1,26 @@
+from ..matrix import vector
+
+__all__ = ['Infinity', 'ideal_point_to_r13']
+
+Infinity = 'Infinity'
+
+
+def ideal_point_to_r13(z, RF):
+    """
+    Takes a boundary point z of H^3, that is either a complex number
+    or Infinite, and a real field type.
+
+    Returns the corresponding unit light vector in the hyperboloid model.
+    """
+    if z == Infinity:
+        return vector([RF(1), RF(1), RF(0), RF(0)])
+
+    z_re = z.real()
+    z_im = z.imag()
+    z_abs_sqr = z_re**2 + z_im**2
+    denom = z_abs_sqr + 1
+
+    return vector([RF(1),
+                   (z_abs_sqr - 1) / denom,
+                   2 * z_re / denom,
+                   2 * z_im / denom])

snappy/verify/__init__.py

@@ -0,0 +1,13 @@
+from .interval_newton_shapes_engine import *
+from .krawczyk_shapes_engine import *
+
+from .hyperbolicity import *
+from .canonical import *
+from .cusp_translations import *
+from .volume import *
+from .complex_volume import *
+from .interval_tree import *
+
+# Choice of algorithm for finding intervals
+CertifiedShapesEngine = KrawczykShapesEngine
+# CertifiedShapesEngine = IntervalNewtonShapesEngine