snappy 3.2__cp311-cp311-macosx_10_12_x86_64.whl

snappy/hyperboloid/__init__.py

@@ -0,0 +1,212 @@
+from ..matrix import make_vector, make_matrix, mat_solve
+
+from ..sage_helper import _within_sage
+
+"""
+hyperboloid contains methods relating to the hyperboloid model
+
+          { (t, x, y, z) : -t^2 + x^2 + y^2 + z^2 = -1, t > 0 }
+
+in the Minkowski space with signature -+++.
+
+Conventions:
+
+Points in the space are represented as vectors of 4 real numbers.
+Here vector is a vector as constructed with snappy.matrix.vector(...)
+(that is either snappy's own SimpleVector or a SageMath vector type)
+from a real type (either a SnapPy.Number or one
+of SageMath's real types including RealIntervalField, but not python's
+native float type).
+
+Similarly, O13-matrices are represented as matrices as constructed with
+snappy.matrix.matrix(...) from a real type.
+
+Note that we mostly follow the SnapPea kernel conventions, except that
+we call the same matrices O13 rather than O31. This reads better given
+that the signature is -+++: O13 reflects that is the first entry in a
+vector or column in matrix that has the special role corresponding to
+the time component or being a time-like vector, respectively.
+
+"""
+
+
+def r13_dot(u, v):
+    """
+    -+++ inner product of two 4-vectors.
+    """
+    return -u[0]*v[0] + u[1]*v[1] + u[2]*v[2] + u[3]*v[3]
+
+
+def time_r13_normalise(u):
+    """
+    Given a time-like vector in Minkowski space, returns the normalised
+    vector (with norm -1).
+    """
+
+    return u / (-r13_dot(u,u)).sqrt()
+
+
+def space_r13_normalise(u):
+    """
+    Given a space-like vector in Minkowski space, returns the normalised
+    vector (with norm 1).
+    """
+
+    return u / r13_dot(u,u).sqrt()
+
+
+def o13_inverse(m):
+    """
+    Given a O13 matrix, return its inverse.
+    """
+
+    result = m.transpose()
+    result[0,1] = -result[0,1]
+    result[0,2] = -result[0,2]
+    result[0,3] = -result[0,3]
+    result[1,0] = -result[1,0]
+    result[2,0] = -result[2,0]
+    result[3,0] = -result[3,0]
+
+    return result
+
+def so13_to_pgl2c(B):
+    """
+    Given an SO13 matrix, returns corresponding complex 2x2-matrix.
+    The determinant of the result is not 1 in general.
+
+    Python implementation of O31_to_Moebius (without normalization).
+    """
+
+    AM0A_00 = B[0,0] + B[1,0]
+    AM1A_00 = B[0,1] + B[1,1]
+    aa = AM0A_00 + AM1A_00
+    bb = AM0A_00 - AM1A_00
+
+    if aa > bb:
+        return _to_complex_matrix(
+            aa,                0               ,
+            B[0,2] + B[1,2],   B[0,3] + B[1,3] ,
+
+            B[2,0] + B[2,1], -(B[3,0] + B[3,1]),
+            B[2,2] + B[3,3],   B[2,3] - B[3,2]   )
+    else:
+        return _to_complex_matrix(
+            B[0,2] + B[1,2], -(B[0,3] + B[1,3]),
+            bb             ,   0               ,
+            B[2,2] - B[3,3], -(B[2,3] + B[3,2]),
+            B[2,0] - B[2,1],   B[3,1] - B[3,0]   )
+
+def so13_to_psl2c(m):
+    """
+    Given an SO13 matrix, returns corresponding complex 2x2-matrix
+    with determinant 1.
+
+    Python implementation of O31_to_Moebius (with normalization).
+    """
+
+    A = so13_to_pgl2c(m)
+    return A / A.det().sqrt()
+
+def r13_to_klein(v):
+    """
+    Given a time-like or light-like vector, gives the respective point
+    in the Klein model or its boundary, respectively.
+    """
+
+    return make_vector([v[1] / v[0], v[2] / v[0], v[3] / v[0]])
+
+def unit_time_vector_to_o13_hyperbolic_translation(v):
+    """
+    Takes a point (time-like unit vector) in the hyperboloid model and
+    returns the O13-matrix corresponding to the hyperbolic translation
+    moving the origin to that point (that is, the translation fixing
+    the geodesic between the origin and the point and introducing no
+    rotation about that geodesic).
+    """
+
+    v1 = [1 + v[0], v[1], v[2], v[3]]
+
+    m = [ [ x * y / v1[0] for x in v1] for y in v1 ]
+    m[0][0] -= 1
+    m[1][1] += 1
+    m[2][2] += 1
+    m[3][3] += 1
+
+    return make_matrix(m)
+
+
+def unnormalised_plane_eqn_from_r13_points(pts):
+    """
+    Given three (finite or ideal) points in the hyperboloid model
+    (that is time-like or light-like vectors), compute the space-like
+    vector x such that the plane defined by x * y = 0 contains the
+    three given points.
+    """
+
+    return make_vector([  _det_shifted_matrix3(pts, 0),
+                          _det_shifted_matrix3(pts, 1),
+                        - _det_shifted_matrix3(pts, 2),
+                          _det_shifted_matrix3(pts, 3)])
+
+
+def _det_shifted_matrix3(m, i):
+    """
+    Computes determinant of 3x3 matrix obtained by picking
+    3 rows from the given 3x4 matrix m.
+    """
+
+    i0 = (i+1) % 4
+    i1 = (i+2) % 4
+    i2 = (i+3) % 4
+
+    return (  m[0][i0] * m[1][i1] * m[2][i2]
+            + m[0][i1] * m[1][i2] * m[2][i0]
+            + m[0][i2] * m[1][i0] * m[2][i1]
+            - m[0][i2] * m[1][i1] * m[2][i0]
+            - m[0][i0] * m[1][i2] * m[2][i1]
+            - m[0][i1] * m[1][i0] * m[2][i2])
+
+def compute_inradius_and_incenter_from_planes(planes):
+    """
+    Given outside-facing normals for the four faces of a
+    tetrahedron, compute the hyperbolic inradius and the
+    incenter (as unit time vector) of the tetrahedron (in the
+    hyperboloid model).
+    """
+
+    # We need to c and r such that
+    #  * r13_dot(c, c) = -1 and
+    #  * r13_dot(plane, c) = -sinh(r) for every plane
+    #
+    # We instead solve for the following system of linear equations:
+    #  * r13_dot(plane, pt) = -1 for every plane
+
+    RF = planes[0][0].parent()
+    m = make_matrix([[-plane[0], plane[1], plane[2], plane[3]]
+                     for plane in planes])
+    v = make_vector([RF(-1), RF(-1), RF(-1), RF(-1)])
+
+    pt = mat_solve(m, v)
+
+    # And then use the inverse length of pt to scale pt to be
+    # a unit time vector and to compute the r.
+    scale = 1 / (-r13_dot(pt, pt)).sqrt()
+
+    return scale.arcsinh(), scale * pt
+
+def _to_complex_matrix(
+        a, b,    c, d,
+        e, f,    g, h):
+    RF = a.parent()
+    if _within_sage:
+        CF = RF.complex_field()
+        return make_matrix(
+            [ [ CF(a,b), CF(c, d) ],
+              [ CF(e,f), CF(g, h) ] ],
+            ring=CF)
+    else:
+        I = RF('I')
+        return make_matrix(
+            [ [ a + b * I, c + d * I ],
+              [ e + f * I, g + h * I ] ])

snappy/hyperboloid/distances.py

@@ -0,0 +1,245 @@
+from .triangle import R13IdealTriangle
+from .line import R13Line
+from .point import R13Point
+from .horoball import R13Horoball
+from . import r13_dot
+
+from ..math_basics import is_RealIntervalFieldElement # type: ignore
+from ..sage_helper import _within_sage # type: ignore
+
+if _within_sage:
+    from ..sage_helper import Infinity
+
+__all__ = ['distance_r13_lines',
+           'lower_bound_distance_r13_line_triangle']
+
+def distance_r13_lines(line0 : R13Line, line1 : R13Line):
+    """
+    Computes distance between two hyperbolic lines.
+    """
+
+    p00 = r13_dot(line0.points[0], line1.points[0])
+    p01 = r13_dot(line0.points[0], line1.points[1])
+    p10 = r13_dot(line0.points[1], line1.points[0])
+    p11 = r13_dot(line0.points[1], line1.points[1])
+
+    pp = line0.inner_product * line1.inner_product
+
+    t0 = _safe_sqrt((p00 * p11) / pp)
+    t1 = _safe_sqrt((p01 * p10) / pp)
+
+    p = (t0 + t1 - 1) / 2
+
+    return 2 * _safe_sqrt(p).arcsinh()
+
+def distance_r13_horoballs(horoball_defining_vec0,
+                           horoball_defining_vec1):
+    p = -r13_dot(horoball_defining_vec0, horoball_defining_vec1) / 2
+    return _safe_log(p)
+
+def distance_r13_horoball_line(horoball_defining_vec, # Light-like
+                               line : R13Line):
+
+    p = (r13_dot(line.points[0], horoball_defining_vec) *
+         r13_dot(line.points[1], horoball_defining_vec))
+    s = -2 * p / line.inner_product
+
+    return _safe_log(s)/2
+
+def distance_r13_horoball_plane(horoball_defining_vec, # Light-like
+                                plane_defining_vec): # Unit space-like
+    p = r13_dot(horoball_defining_vec, plane_defining_vec)
+    return _safe_log_of_abs(p)
+
+def distance_r13_horoball_point(horoball_defining_vec, # Light-like
+                                pt): # Unit-time-like
+    p = r13_dot(horoball_defining_vec, pt)
+    return (-p).log()
+
+def distance_r13_point_line(pt, # Unit time-like
+                            line : R13Line):
+    """
+    This also works if line is degenerate and starts and ends at some point.
+    """
+
+    p = (r13_dot(line.points[0], pt) *
+         r13_dot(line.points[1], pt))
+    s = _safe_div(2 * p, -line.inner_product)
+    return _safe_arccosh(_safe_sqrt(s))
+
+def distance_r13_point_plane(pt, # Unit time-like
+                             plane_defining_vec): # Unit space-like
+    p = r13_dot(pt, plane_defining_vec)
+    return p.arcsinh().abs()
+
+def distance_r13_points(pt0, # Unit time-like
+                        pt1): # Unit time-like
+    """
+    Computes the hyperbolic distance between two points (represented
+    by unit time vectors) in the hyperboloid model.
+    """
+    p = r13_dot(pt0, pt1)
+
+    # Due to rounding errors, the resulting number or interval can be
+    # slightly less than 1 or contain numbers slightly less than 1,
+    # respectively - resulting in NaN's. Avoid this here.
+    return _safe_arccosh(-p)
+
+def lower_bound_distance_to_r13_triangle(
+        geometric_object, triangle : R13IdealTriangle, verified : bool):
+    if isinstance(geometric_object, R13Horoball):
+        return lower_bound_distance_r13_horoball_triangle(
+            geometric_object.defining_vec, triangle, verified)
+    if isinstance(geometric_object, R13Line):
+        return lower_bound_distance_r13_line_triangle(
+            geometric_object, triangle, verified)
+    if isinstance(geometric_object, R13Point):
+        return lower_bound_distance_r13_point_triangle(
+            geometric_object.point, triangle, verified)
+    raise ValueError(
+        "Distance between %r and triangle not supported" % geometric_object)
+
+def lower_bound_distance_r13_horoball_triangle(
+        horoball_defining_vec,
+        triangle : R13IdealTriangle, verified : bool):
+
+    if verified:
+        epsilon = 0
+    else:
+        RF = horoball_defining_vec[0].parent()
+        epsilon = _compute_epsilon(RF)
+
+    for bounding_plane, edge in zip(triangle.bounding_planes,
+                                    triangle.edges):
+        if r13_dot(horoball_defining_vec, bounding_plane) > epsilon:
+            return distance_r13_horoball_line(horoball_defining_vec, edge)
+
+    return distance_r13_horoball_plane(
+        horoball_defining_vec, triangle.plane)
+
+def lower_bound_distance_r13_line_triangle(
+        line : R13Line, triangle : R13IdealTriangle, verified : bool):
+
+    if verified:
+        epsilon = 0
+    else:
+        RF = line.points[0][0].parent()
+        epsilon = _compute_epsilon(RF)
+
+    a0 = r13_dot(triangle.plane, line.points[0])
+    a1 = r13_dot(triangle.plane, line.points[1])
+
+    abs0 = abs(a0)
+    abs1 = abs(a1)
+
+    pt = abs1 * line.points[0] + abs0 * line.points[1]
+
+    for bounding_plane, edge in zip(triangle.bounding_planes,
+                                    triangle.edges):
+        if r13_dot(pt, bounding_plane) > epsilon:
+            return distance_r13_lines(line, edge)
+
+    p = a0 * a1
+
+    if p > 0:
+        return (-2 * p / line.inner_product).sqrt().arcsinh()
+
+    RF = line.points[0][0].parent()
+    return RF(0)
+
+def lower_bound_distance_r13_point_triangle(
+        point,
+        triangle : R13IdealTriangle, verified : bool):
+
+    if verified:
+        epsilon = 0
+    else:
+        RF = point[0].parent()
+        epsilon = _compute_epsilon(RF)
+
+    for bounding_plane, edge in zip(triangle.bounding_planes,
+                                    triangle.edges):
+        if r13_dot(point, bounding_plane) > epsilon:
+            return distance_r13_point_line(point, edge)
+
+    return distance_r13_point_plane(point, triangle.plane)
+
+def _compute_epsilon(RF):
+    return RF(0.5) ** (RF.prec() // 2)
+
+def _safe_sqrt(p):
+    """
+    Compute the sqrt of a number that is known to be non-negative
+    though might not be non-negative because of floating point
+    issues. When using interval arithmetic, this means that
+    while the upper bound will be non-negative, the lower bound
+    we computed might be negative because it is too conservative.
+
+    Example of a quantity that can be given to this function:
+    negative inner product of two vectors in the positive
+    light cone. This is because we know that the inner product
+    of two such vectors is always non-positive.
+    """
+
+    if is_RealIntervalFieldElement(p):
+        RIF = p.parent()
+        p = p.intersection(RIF(0, Infinity))
+    else:
+        if p < 0:
+            RF = p.parent()
+            return RF(0)
+    return p.sqrt()
+
+def _safe_log(p):
+    if is_RealIntervalFieldElement(p):
+        RIF = p.parent()
+        p = p.intersection(RIF(0, Infinity))
+    else:
+        if p <= 0:
+            RF = p.parent()
+            return RF(-1e20)
+    return p.log()
+
+def _safe_log_of_abs(p):
+    return _safe_log_non_neg(p.abs())
+
+def _safe_log_non_neg(p):
+    if p == 0:
+        if is_RealIntervalFieldElement(p):
+            RIF = p.parent()
+            return RIF(-Infinity)
+        else:
+            RF = p.parent()
+            return RF(-1e20)
+    else:
+        return p.log()
+
+def _safe_arccosh(p):
+    if is_RealIntervalFieldElement(p):
+        RIF = p.parent()
+        p = p.intersection(RIF(1, Infinity))
+    else:
+        if p < 1:
+            RF = p.parent()
+            return RF(0)
+    return p.arccosh()
+
+def _safe_div(a, b):
+    """
+    Compute a / b where be is known to be non-negative and we should
+    return infinity if b is zero.
+    """
+    
+    if is_RealIntervalFieldElement(b):
+        RIF = b.parent()
+        if b == 0:
+            return RIF(Infinity)
+        else:
+            return a / b.intersection(RIF(0, Infinity))
+    else:
+        if b <= 0:
+            RIF = b.parent()
+            return RIF(1e20)
+        else:
+            return a / b
+

snappy/hyperboloid/horoball.py

@@ -0,0 +1,19 @@
+__all__ = ['R13Horoball']
+
+class R13Horoball:
+    """
+    Horoball defined by { x : r13_dot(x, l) > -1 } where l is a
+    light-like vector.
+    """
+
+    def __init__(self,
+                 defining_vec): # Light-like vector
+        self.defining_vec = defining_vec
+
+    def transformed(self,
+                    m): # O13-matrix
+        """
+        Returns image of the horoball under given O13-matrix m.
+        """
+
+        return R13Horoball(m * self.defining_vec)

snappy/hyperboloid/line.py

@@ -0,0 +1,35 @@
+from ..hyperboloid import r13_dot
+
+__all__ = [ 'R13Line' ]
+
+class R13Line:
+    """
+    A line in the hyperboloid model - represented by two
+    like-like vectors spanning the line.
+
+    For distance computations, the inner product between the two
+    vectors is stored as well.
+    """
+
+    def __init__(self,
+                 points, # Two light-like vectors
+                 inner_product=None): # Optional: their inner product
+        """
+        inner_product can be given if known, otherwise, will be computed.
+        """
+        self.points = points
+        if inner_product is None:
+            self.inner_product = r13_dot(points[0], points[1])
+        else:
+            self.inner_product = inner_product
+
+    def transformed(self,
+                    m): # O13-matrix
+        """
+        Returns image of the line under given O13-matrix m.
+        """
+
+        return R13Line(
+            [ m * point for point in self.points],
+            self.inner_product)
+

snappy/hyperboloid/point.py

@@ -0,0 +1,9 @@
+__all__ = [ 'R13Point' ]
+
+class R13Point:
+    def __init__(self, point):
+        self.point = point
+
+    def transformed(self,
+                    m): # O13-matrix
+        return R13Point(m * self.point)

snappy/hyperboloid/triangle.py

@@ -0,0 +1,29 @@
+from .line import R13Line
+from . import (time_r13_normalise,
+               space_r13_normalise,
+               r13_dot)
+
+from typing import Sequence
+
+__all__ = ['R13IdealTriangle']
+
+class R13IdealTriangle:
+    def __init__(self,
+                 plane, # one space-like normal vector
+                 bounding_planes, # three space-like normal vectors
+                 edges : Sequence[R13Line] # Same order as bounding_planes
+                 ):
+        self.plane = plane
+        self.bounding_planes = bounding_planes
+        self.edges = edges
+
+def triangle_bounding_plane(v_opp, v0, v1):
+    m = time_r13_normalise(
+        -(r13_dot(v1, v_opp) * v0 + r13_dot(v0, v_opp) * v1))
+
+    return _make_r13_unit_tangent_vector(m - v_opp, m)
+
+def _make_r13_unit_tangent_vector(direction, point):
+    s = r13_dot(direction, point)
+    return space_r13_normalise(direction + s * point)
+

snappy/infowindow.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+import sys
+import os
+import datetime
+from .gui import *
+from .version import version as SnapPy_version
+from IPython import __version__ as IPython_version
+
+snappy_path = os.path.dirname(__file__)
+icon_file = os.path.join(snappy_path, 'info_icon.gif')
+
+
+class InfoWindow(Tk_.Toplevel):
+    def __init__(self, root, title, content, root_attr_name):
+        self.root = root
+        self.root_attr_name = root_attr_name
+        setattr(root, root_attr_name, self)
+        Tk_.Toplevel.__init__(self, self.root, class_='snappy')
+        self.title(title)
+        self.content = content
+        self.image = Tk_.PhotoImage(file=icon_file)
+        self.style = SnapPyStyle()
+        self.body()
+
+    def body(self):
+        self.resizable(False, False)
+        box = ttk.Frame(self)
+        icon = ttk.Label(box, image=self.image)
+        icon.grid(row=0, column=0, pady=30, sticky=Tk_.N)
+        message = Tk_.Message(box, text=self.content)
+        message.grid(row=0, column=1, padx=20, pady=10)
+        box.pack()
+
+    def destroy(self):
+        if hasattr(self.root, self.root_attr_name):
+            delattr(self.root, self.root_attr_name)
+        Tk_.Toplevel.destroy(self)
+
+
+about_snappy_text = """
+For information on how to use SnapPy, please see the Help menu.
+
+SnapPy is a program for studying the topology and geometry of 3-manifolds, with a focus on hyperbolic structures. It was written by Marc Culler, Nathan Dunfield, Matthias Gӧrner, and Jeff Weeks, with additional contributions by many others.  Its homepage is
+
+     http://snappy.computop.org/
+
+This is version %s of SnapPy, running on Python %s using Tk %s and IPython %s.
+
+Development of SnapPy was made possible in part by generous support from the National Science Foundation of the United States.
+
+SnapPy is copyright © 2009-%d by Marc Culler, Nathan Dunfield, Matthias Gӧrner, Jeff Weeks, and others and is distributed under the GNU Public License, version 2 or later.
+""" % (SnapPy_version,
+       sys.version.split()[0],
+       Tk_.Tcl().eval('info patchlevel'),
+       IPython_version,
+       datetime.datetime.now().year)
+
+
+def about_snappy(window):
+    return InfoWindow(window, 'About SnapPy', about_snappy_text, 'about_snappy')
+
+
+if __name__ == '__main__':
+    root = Tk_.Tk()
+    info = InfoWindow(root, title='About SnapPy', content=about_snappy_text)