snappy 3.3__cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

snappy/dev/vericlosed/oneVertexTruncatedComplex.py

@@ -0,0 +1,122 @@
+from snappy.snap import t3mlite as t3m
+
+from truncatedComplex import *
+
+class OneVertexTruncatedComplex(TruncatedComplex):
+
+    def __init__(self, hyperbolic_structure):
+        super().__init__(
+            hyperbolic_structure.mcomplex)
+
+        self.hyperbolic_structure = hyperbolic_structure
+
+        if len(hyperbolic_structure.mcomplex.Vertices) != 1:
+            raise Exception("Expected one vertex triangulation")
+        
+        self._compute_shortest_paths()
+        self._compute_loops()
+        self._check_consistency()
+        self._compute_matrices_for_loops()
+        self._compute_fixed_pts()
+
+    def _compute_shortest_paths(self):
+
+        base_tet_and_perm = (0, t3m.Perm4([0,1,2,3]))
+
+        self.tet_and_perm_to_edge = {
+            self.get_key(base_tet_and_perm) : None
+        }
+
+        pending = [ base_tet_and_perm ]
+
+        self.alpha_edges = [ None for edge in self.mcomplex.Edges ]
+
+        while pending:
+            tet_and_perm = pending.pop()
+
+            edge_index, edge_end = (
+                self.get_edge_index_and_end_from_tet_and_perm(
+                    tet_and_perm))
+
+            if edge_end == 0 and self.alpha_edges[edge_index] is None:
+                self.alpha_edges[edge_index] = TruncatedComplex.Edge(
+                    'alpha', tet_and_perm)
+            
+            for edge in self.get_edges_for_tet_and_perm(tet_and_perm):
+                
+                if edge.subcomplex_type != 'alpha':
+
+                    tet_and_perm_of_end = edge.tet_and_perm_of_end()
+                    
+                    key = self.get_key(tet_and_perm_of_end)
+                
+                    if key not in self.tet_and_perm_to_edge:
+                        self.tet_and_perm_to_edge[key] = edge
+                        pending.append(tet_and_perm_of_end)
+                        
+    def _compute_shortest_path(self, tet_and_perm):
+
+        result = []
+
+        while True:
+            key = self.get_key(tet_and_perm)
+            
+            edge = self.tet_and_perm_to_edge[key]
+            if edge is None:
+                return result[::-1]
+
+            result.append(edge)
+            tet_and_perm = edge.tet_and_perm
+
+    @staticmethod
+    def _reverse_path(path):
+        return [ edge.reverse() for edge in path[::-1] ]
+                
+    def _compute_loop(self, alpha_edge):
+
+        s = alpha_edge.tet_and_perm
+        path_to_s = self._compute_shortest_path(s)
+
+        e = alpha_edge.tet_and_perm_of_end()
+        path_to_e = self._compute_shortest_path(e)
+        path_from_e = OneVertexTruncatedComplex._reverse_path(path_to_e)
+
+        return path_to_s + [ alpha_edge ] + path_from_e
+
+    def _compute_loops(self):
+        self.loops = [ self._compute_loop(alpha_edge)
+                       for alpha_edge in self.alpha_edges ]
+
+    def _check_consistency(self):
+
+        for loop in self.loops:
+            self.check_loop(loop)
+                
+    def _compute_matrices_for_loops(self):
+        def _to_psl(m):
+            return m / m.determinant().sqrt()
+
+        self.matrix_for_loops = [
+            _to_psl(self.hyperbolic_structure.pgl2_matrix_for_path(loop))
+            for loop in self.loops ]
+
+    def _compute_fixed_pts(self):
+        self.fixed_pts_for_loops = [
+            _fixed_points(m) for m in self.matrix_for_loops ]
+
+def _fixed_points(m):
+    # (a * z + b) = z * (c * z + d)
+    # z^2 + (d - a) / c * z - b / c = 0
+
+    # p' = (a - d) / 2 * c
+    # q = - b / c
+
+    # p' +/- sqrt( p'^2 - q ) = -p' +/- sqrt(p'^2 + b / c)
+
+    cinv = 1 / m[1, 0]
+
+    p = (m[0,0] - m[1,1]) * cinv / 2
+    d = p ** 2 + m[0,1] * cinv
+
+    s = d.sqrt()
+    return [p - s, p + s]

snappy/dev/vericlosed/orb/__init__.py

@@ -0,0 +1 @@
+# Directory to find orb binary

snappy/dev/vericlosed/parseVertexGramMatrixFile.py

@@ -0,0 +1,47 @@
+from .hyperbolicStructure import HyperbolicStructure
+
+from .verificationError import *
+
+from sage.all import vector, RealDoubleField, sqrt
+
+__all__ = ['compute_approx_hyperbolic_structure_from_vertex_gram_matrix_file']
+
+def normalize_gram_matrix(m):
+    for i in range(4):
+        if not (m[i][i] < 0):
+            raise OrbVertexGramMatrixError(
+                "Non-negative entry in vertex gram matrix")
+
+    return [[ -1 if i == j else m[i][j] / sqrt(m[i][i] * m[j][j])
+               for j in range(4) ] for i in range(4) ]
+
+def normalize_gram_matrices(ms):
+    return [ normalize_gram_matrix(m) for m in ms ]
+
+def edge_parameter_from_normalized_gram_matrices(edge, gram_matrices):
+    corner = edge.Corners[0]
+
+    s = corner.Subsimplex
+    i, j = [ k for k in range(4) if s & (1 << k) ]
+    return gram_matrices[corner.Tetrahedron.Index][i][j]
+
+def edge_parameters_from_normalized_gram_matrices(mcomplex, gram_matrices):
+    return [ edge_parameter_from_normalized_gram_matrices(e, gram_matrices)
+             for e in mcomplex.Edges ]
+
+def edge_parameters_from_gram_matrices(mcomplex, gram_matrices):
+    return vector(
+        RealDoubleField(),
+        edge_parameters_from_normalized_gram_matrices(
+            mcomplex,
+            normalize_gram_matrices(gram_matrices)))
+
+def edge_parameters_from_vertex_gram_matrix_file(mcomplex, filename):
+    return edge_parameters_from_gram_matrices(
+        mcomplex, eval(open(filename).read()))
+
+def compute_approx_hyperbolic_structure_from_vertex_gram_matrix_file(
+                mcomplex, filename):
+    return HyperbolicStructure(
+        mcomplex,
+        edge_parameters_from_vertex_gram_matrix_file(mcomplex, filename))

snappy/dev/vericlosed/polishApproxHyperbolicStructure.py

@@ -0,0 +1,61 @@
+from .hyperbolicStructure import *
+from .verificationError import *
+
+from sage.all import RealField, vector
+
+__all__ = ['polish_approx_hyperbolic_structure']
+
+def polish_approx_hyperbolic_structure(
+                approx_hyperbolic_structure, bits_prec = 53,
+                verbose = False):
+
+    RF = RealField(bits_prec + 20)
+
+    twoPi = 2 * RF.pi()
+
+    edge_parameters = vector(RF, approx_hyperbolic_structure.edge_lengths)
+
+    epsilon = RF(0.5) ** bits_prec
+
+    if not (approx_hyperbolic_structure.exact_edges and
+            approx_hyperbolic_structure.var_edges):
+        raise Exception("Did not pick exact/var edges")
+
+    for i in range(100):
+        try:
+            result = HyperbolicStructure(
+                approx_hyperbolic_structure.mcomplex,
+                edge_parameters,
+                approx_hyperbolic_structure.exact_edges,
+                approx_hyperbolic_structure.var_edges)
+        except BadDihedralAngleError as e:
+            raise PolishingFailedWithBadDihedralAngleError("When polishing", e)
+        
+
+        errs = vector(
+            [result.angle_sums[e] - twoPi for e in result.exact_edges])
+
+        max_err = max([abs(err) for err in errs])
+
+        if verbose:
+            print("Iteration %d: error = %s" % (i, RealField(53)(max_err)))
+
+        if max_err < epsilon:
+            return result
+
+        j = result.full_rank_jacobian_submatrix()
+        try:
+            jinv = j.inverse()
+        except ZeroDivisionError:
+            raise PolishingError("Singular matrix")
+
+        delta = jinv * errs
+        
+        for e, d in zip(result.var_edges, delta):
+            edge_parameters[e] -= d
+
+    print("Max error", max_err)
+    print(approx_hyperbolic_structure.full_rank_jacobian_submatrix().SVD()[1].diagonal())
+
+    raise PolishingError("Newton method did not produce a result")
+

snappy/dev/vericlosed/test.py

@@ -0,0 +1,54 @@
+import branchedDoubleCover
+import veriClosed
+from veriClosed import *
+from veriClosed.verifyHyperbolicStructureEngine import *
+from veriClosed.testing.cocycleTester import *
+
+from veriClosed.testing import __path__ as testPaths
+testPath = testPaths[0]
+
+from snappy import Triangulation
+from snappy.sage_helper import doctest_modules
+
+import os
+import sys
+
+def testCocycles(isoSig):
+    """
+    Testing.
+
+        >>> testCocycles("kLLLvQQkccfgighjijjlnannwnashp")
+        True
+        >>> testCocycles("qLLvLAzMAQAkcdjifjhlnkmlnnopphsksskcimafjwovqw")
+        True
+
+    """    
+
+        
+    T = Triangulation(isoSig, remove_finite_vertices = False)
+    hyperbolic_structure = compute_verified_hyperbolic_structure(T, source = 'new', bits_prec = 106)
+    engine = VerifyHyperbolicStructureEngine(hyperbolic_structure)
+    tester = CocycleTester(engine)
+    tester.test()
+
+    return True
+
+def testVerifyFromVertexGramMatrixFile():
+    """
+    Testing.
+      
+        >>> f = os.path.join(testPath, "m004_1_2.tri")
+        >>> T = Triangulation(f, remove_finite_vertices = False)
+        >>> bool(compute_verified_hyperbolic_structure(T, source = f + '.vgm'))
+        True
+    """
+
+def _doctest():
+    doctest_modules(
+        [ sys.modules[__name__],
+          veriClosed.computeVerifiedHyperbolicStructure,
+          branchedDoubleCover])
+
+if __name__ == '__main__':
+    _doctest()
+    

snappy/dev/vericlosed/truncatedComplex.py

@@ -0,0 +1,176 @@
+from snappy.snap import t3mlite as t3m
+
+__all__ = ['TruncatedComplex']
+
+
+class TruncatedComplex():
+
+    class SubcomplexBase():
+        def __init__(self, subcomplex_type, tet_and_perm):
+            self.subcomplex_type = subcomplex_type
+            self.tet_and_perm = tet_and_perm
+
+    class Edge(SubcomplexBase):
+        """
+        tet_and_perm is a pair (index of tet, perm) parametrizing a vertex in
+        the truncated complex. This vertex is where the directed edge starts.
+
+        """
+
+        def tet_and_perm_of_end(self):
+            """
+            Get the pair (index of tet, perm) parametrizing the vertex of the
+            truncated complex where the directed edge ends.
+            """
+
+            tet_index, p = self.tet_and_perm
+            if self.subcomplex_type == 'alpha':
+                return (tet_index, p * t3m.Perm4([1,0,2,3]))
+            if self.subcomplex_type == 'beta':
+                return (tet_index, p * t3m.Perm4([0,2,1,3]))
+            if self.subcomplex_type == 'gamma':
+                return (tet_index, p * t3m.Perm4([0,1,3,2]))
+
+            raise Exception("Unknown subcomplex_type for Edge")
+
+        def reverse(self):
+            """
+            Reverse the direction of the edge.
+            """
+
+            return TruncatedComplex.Edge(
+                self.subcomplex_type, self.tet_and_perm_of_end())
+
+        def __repr__(self):
+            return 'TruncatedComplex.Edge(%r, %r)' % (
+                self.subcomplex_type, self.tet_and_perm)
+
+    class EdgeLoop(SubcomplexBase):
+        def __init__(self, tet_and_perm, edge_index):
+            super(TruncatedComplex.EdgeLoop, self).__init__('edgeLoop', tet_and_perm)
+            self.edge_index = edge_index
+
+        def tet_and_perm_of_end(self):
+            return self.tet_and_perm
+
+        def __repr__(self):
+            return 'TruncatedComplex.EdgeLoop(%r, %d)' % (
+                self.tet_and_perm, self.edge_index)
+
+    def __init__(self, mcomplex):
+        self.mcomplex = mcomplex
+
+        # maps to tet and perm to 0 or 1 to indicate the end of the edge
+        self.tet_and_perm_to_end_of_edge = {
+            (tet.Index, p2.tuple()) : end
+            for i, edge in enumerate(mcomplex.Edges)
+            for tet, perm in edge.embeddings()
+            for end, p in [ (0, perm), (1, perm * t3m.Perm4([1,0,2,3])) ]
+            for p2 in [ p, p * t3m.Perm4([0,1,3,2]) ] }
+
+    def get_glued_tet_and_perm(self, tet_and_perm):
+        """
+        The face pairings of the tetrahedra make it such that two
+        pairs (index of tet, perm) parametrize the same vertex in the
+        truncated complex. Given a pair, return the other pair.
+        """
+
+        tet_index, p = tet_and_perm
+        
+        face = p.image(t3m.F3)
+        tet = self.mcomplex.Tetrahedra[tet_index]
+
+        return (tet.Neighbor[face].Index, tet.Gluing[face] * p)
+
+    def get_key(self, tet_and_perm):
+        """
+        Recall that there are two pairs (index of tet, perm) corresponding
+        to the same vertex in the truncated complex. Pick the lexicographically
+        smallest (when converting perm to a tuple so that it is hashable).
+        This can be used as key in a dictionary mapping vertices of the
+        truncated complex to something.
+        """
+
+        def to_tuple(tet_and_perm):
+            tet, perm = tet_and_perm
+            return (tet, perm.tuple())
+
+        return min(to_tuple(tet_and_perm),
+                   to_tuple(self.get_glued_tet_and_perm(tet_and_perm)))
+    
+    def get_edges_for_tet_and_perm(self, tet_and_perm):
+        """
+        Given a vertex in the truncated complex parametrized by
+        (index of tet, perm), return all four edges starting at that
+        vertex.
+        """
+
+        other_tet_and_perm = self.get_glued_tet_and_perm(tet_and_perm)
+
+        return [
+            TruncatedComplex.Edge('alpha', tet_and_perm),
+            TruncatedComplex.Edge('beta',  tet_and_perm),
+            TruncatedComplex.Edge('gamma', tet_and_perm),
+            TruncatedComplex.Edge('gamma', other_tet_and_perm) ]
+
+
+    @staticmethod
+    def get_edges_of_small_hexagon(tet_and_perm):
+        tet_index, p = tet_and_perm
+        return [
+            TruncatedComplex.Edge('beta',  tet_and_perm),
+            TruncatedComplex.Edge('gamma', (tet_index, p * t3m.Perm4([0,2,1,3]))),
+            TruncatedComplex.Edge('beta',  (tet_index, p * t3m.Perm4([0,2,3,1]))),
+            TruncatedComplex.Edge('gamma', (tet_index, p * t3m.Perm4([0,3,2,1]))),
+            TruncatedComplex.Edge('beta' , (tet_index, p * t3m.Perm4([0,3,1,2]))),
+            TruncatedComplex.Edge('gamma', (tet_index, p * t3m.Perm4([0,1,3,2]))) ]
+
+    @staticmethod
+    def get_edges_of_rectangle(tet_and_perm):
+        tet_index, p = tet_and_perm
+        return [
+            TruncatedComplex.Edge('gamma', tet_and_perm),
+            TruncatedComplex.Edge('alpha', (tet_index, p * t3m.Perm4([0,1,3,2]))),
+            TruncatedComplex.Edge('gamma', (tet_index, p * t3m.Perm4([1,0,3,2]))),
+            TruncatedComplex.Edge('alpha', (tet_index, p * t3m.Perm4([1,0,2,3]))) ]
+
+    @staticmethod
+    def get_edges_of_big_hexagon(tet_and_perm):
+        tet_index, p = tet_and_perm
+        return [
+            TruncatedComplex.Edge('beta',  tet_and_perm),
+            TruncatedComplex.Edge('alpha', (tet_index, p * t3m.Perm4([0,2,1,3]))),
+            TruncatedComplex.Edge('beta',  (tet_index, p * t3m.Perm4([2,0,1,3]))),
+            TruncatedComplex.Edge('alpha', (tet_index, p * t3m.Perm4([2,1,0,3]))),
+            TruncatedComplex.Edge('beta',  (tet_index, p * t3m.Perm4([1,2,0,3]))),
+            TruncatedComplex.Edge('alpha', (tet_index, p * t3m.Perm4([1,0,2,3])))]
+
+    @staticmethod
+    def get_tet_and_odd_perms_for_vertex(vertex):
+        for corner in vertex.Corners:
+            for perm in t3m.Perm4.A4():
+                p = perm * t3m.Perm4([0,1,3,2])
+                if p.image(t3m.V0) == corner.Subsimplex:
+                    yield corner.Tetrahedron.Index, p
+
+    @staticmethod
+    def get_first_tet_and_odd_perm_for_vertex(vertex):
+        for tet_and_perm in TruncatedComplex.get_tet_and_odd_perms_for_vertex(
+                                                                        vertex):
+            return tet_and_perm
+
+    def get_edge_index_and_end_from_tet_and_perm(self, tet_and_perm):
+        tet_index, p = tet_and_perm
+        tet = self.mcomplex.Tetrahedra[tet_index]
+        return (
+            tet.Class[p.image(t3m.E01)].Index,
+            self.tet_and_perm_to_end_of_edge[(tet_index, p.tuple())])
+
+    def check_loop(self, loop):
+        l = len(loop)
+        for i in range(l):
+            s = loop[ i       ].tet_and_perm_of_end()
+            e = loop[(i+1) % l].tet_and_perm
+
+            if self.get_key(s) != self.get_key(e):
+                raise Exception("Failed to be a loop at %d: %r" % (i, loop))

snappy/dev/vericlosed/verificationError.py

@@ -0,0 +1,58 @@
+class VerificationError(RuntimeError):
+    pass
+
+class BadVertexGramMatrixError(VerificationError):
+    '''
+    Failed to verify that vertex gram matrix is realized by a finite tetrahedron.
+    '''
+    pass
+
+class AngleSumIntervalNotContainingTwoPiError(VerificationError):
+    '''
+    The interval for the sum of the dihedral angles adjacent to an edge is
+    2 * pi.
+    '''
+    pass
+
+class GimbalDerivativeNotInvertibleError(VerificationError):
+    pass
+
+class VertexHasNoApproxEdgeError(VerificationError):
+    pass
+
+class NewtonMethodError(VerificationError):
+    pass
+
+class NewtonStepError(NewtonMethodError):
+    pass
+
+class NewtonMethodConvergenceError(NewtonMethodError):
+    pass
+
+class BadDihedralAngleError(VerificationError):
+    pass
+
+class KrawczykFailedToFinishError(VerificationError):
+    pass
+
+class KrawczykFailedWithBadDihedralAngleError(VerificationError):
+    pass
+
+class OrbSolutionTypeError(VerificationError):
+    pass
+
+class UnknownOrbFailureError(VerificationError):
+    pass
+
+class OrbMissingError(VerificationError):
+    pass
+
+class OrbVertexGramMatrixError(VerificationError):
+    pass
+
+class PolishingError(VerificationError):
+    pass
+
+class PolishingFailedWithBadDihedralAngleError(VerificationError):
+    pass
+