snappy 3.3__cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

snappy/dev/vericlosed/gimbalLoopFinder.py

@@ -0,0 +1,130 @@
+from .truncatedComplex import TruncatedComplex
+
+from snappy.snap import t3mlite as t3m
+
+from .verificationError import *
+
+class GimbalLoopFinder:
+    def __init__(self, truncated_complex, vertex, approx_edges):
+        self.truncated_complex = truncated_complex
+        self.vertex = vertex
+        self.approx_edges = approx_edges
+
+        self.uncovered_edge_ends = set()
+        for tet_and_perm in TruncatedComplex.get_tet_and_odd_perms_for_vertex(
+                                                    vertex):
+            edge_index_and_end = (
+                truncated_complex.get_edge_index_and_end_from_tet_and_perm(
+                    tet_and_perm))
+            if edge_index_and_end[0] in approx_edges:
+                self.uncovered_edge_ends.add(edge_index_and_end)
+
+        self.loop = truncated_complex.get_edges_of_small_hexagon(tet_and_perm)
+
+        self.used_hexagons = set()
+
+        self.mark_hexagon_as_used(self.loop)
+        self.insert_edge_loops()
+        
+    def mark_hexagon_as_used(self, edges):
+        for edge in edges:
+            if edge.subcomplex_type == 'beta':
+                tet_index, p = edge.tet_and_perm
+                self.used_hexagons.add((tet_index, p.tuple()))
+
+    def insert_edge_loops(self):
+        position = 0
+        for i in range(len(self.loop)):
+            position = self.insert_edge_loop(position)
+            position += 1
+
+    def insert_edge_loop(self, position):
+        edge = self.loop[position]
+        if edge.subcomplex_type != 'gamma':
+            return position
+
+        edge_index_and_end = (
+            self.truncated_complex.get_edge_index_and_end_from_tet_and_perm(
+                edge.tet_and_perm))
+        if edge_index_and_end not in self.uncovered_edge_ends:
+            return position
+
+        self.uncovered_edge_ends.remove(edge_index_and_end)
+        self.loop.insert(
+            position,
+            TruncatedComplex.EdgeLoop(
+                edge.tet_and_perm, edge_index_and_end[0]))
+        return position + 1
+
+    def expand(self):
+        next_edge = 0
+        while self.uncovered_edge_ends:
+            next_edge = self.expand_at(next_edge)
+            next_edge = (next_edge + 1) % len(self.loop)
+
+    def expand_at(self, position):
+        edge = self.loop[position]
+        if edge.subcomplex_type != 'beta':
+            return position
+
+        other_tet_index, glued_perm = (
+            self.truncated_complex.get_glued_tet_and_perm(
+                edge.tet_and_perm))
+
+        other_perm = glued_perm * t3m.Perm4([0,2,1,3])
+
+        if (other_tet_index, other_perm.tuple()) in self.used_hexagons:
+            return position
+
+        hex = self.truncated_complex.get_edges_of_small_hexagon(
+            (other_tet_index, other_perm))
+        self.mark_hexagon_as_used(hex)
+
+        for i, new_edge in enumerate(hex[1:]):
+            if i == 0:
+                self.loop[position] = new_edge
+            else:
+                position += 1
+                self.loop.insert(position, new_edge)
+
+                position = self.insert_edge_loop(position)
+
+        return position
+        
+
+    def shift_loop_to_start_with_edge_loop(self):
+        for i, edge in enumerate(self.loop):
+            if edge.subcomplex_type == 'edgeLoop':
+                self.loop = self.loop[i:] + self.loop[:i]
+                return
+
+        raise VertexHasNoApproxEdgeError("Vertex has no approx edge")
+
+    def compute_loop(self):
+        self.expand()
+        self.shift_loop_to_start_with_edge_loop()
+
+        self.truncated_complex.check_loop(self.loop)
+
+        return self.loop
+
+    def compute_grouped_loop(self):
+        return _group_loop(self.compute_loop())
+
+    def __repr__(self):
+        return repr(self.edges)
+
+
+def _group_loop(loop):
+    indices = [i for i, edge in enumerate(loop)
+               if edge.subcomplex_type == 'edgeLoop'] + [len(loop)]
+    if 0 not in indices:
+        raise Exception("Missing edgeLoop")
+    result = [
+        [loop[indices[i]], loop[indices[i]+1:indices[i+1]]]
+        for i in range(len(indices) - 1) ]
+    
+    if not sum([ [a] + b for a, b in result ], []) == loop:
+        raise Exception("Error in _group_loop")
+
+    return result

snappy/dev/vericlosed/hyperbolicStructure.py

@@ -0,0 +1,313 @@
+from .verificationError import *
+
+from snappy.snap import t3mlite as t3m
+
+from sage.all import vector, matrix, prod, exp, RealDoubleField, sqrt
+import sage.all
+
+__all__ = ['HyperbolicStructure']
+
+class HyperbolicStructure:
+    def __init__(self, mcomplex, edge_lengths,
+                 exact_edges = None, var_edges = None):
+        """
+        mcomplex is an Mcomplex.
+        edge_lengths are really the edge parameters.
+        exact_edges and var_edges are indices of edges (#edges - 3 * #vertices).
+        They are forming the subsystem of equations that
+        has full rank we use when polishing or applying the Krawczyk test.
+        var_edges correspond to the variables and exact_edges for the sum of dihedral
+        angles we are solving for.
+        """
+
+        self.mcomplex = mcomplex
+        self.edge_lengths = edge_lengths
+        self.exact_edges = exact_edges
+        self.var_edges = var_edges
+        
+        self.vertex_gram_matrices = [
+            _compute_vertex_gram_matrix(tet, edge_lengths)
+            for tet in mcomplex.Tetrahedra ]
+
+        self.vertex_gram_adjoints = [
+            m.adjugate() for m in self.vertex_gram_matrices ]
+
+        self.dihedral_angles = [
+            [ [ _dihedral_angle(vertex_gram_adjoint, i, j)
+                for i in range(4) ] for j in range(4) ]
+            for vertex_gram_adjoint in self.vertex_gram_adjoints ]
+
+        self.angle_sums = [
+            self._angle_sum(edge) for edge in mcomplex.Edges ]
+
+    def _angle_at_corner(self, corner):
+        i, j = [ k for k, z in enumerate(t3m.ZeroSubsimplices)
+                 if not z & corner.Subsimplex ]
+        return self.dihedral_angles[corner.Tetrahedron.Index][i][j]
+    
+    def _angle_sum(self, edge):
+        return sum([self._angle_at_corner(corner)
+                    for corner in edge.Corners])
+    
+    def jacobian(self):
+        s = len(self.mcomplex.Edges)
+        result = matrix(self.vertex_gram_matrices[0].base_ring(), s, s)
+        
+        for tet in self.mcomplex.Tetrahedra:
+            cofactor_matrices = _cofactor_matrices_for_submatrices(
+                self.vertex_gram_matrices[tet.Index])
+            vga = self.vertex_gram_adjoints[tet.Index]
+
+            for angle_edge, (i, j) in _OneSubsimplicesWithVertexIndices:
+                cii = vga[i,i]
+                cij = vga[i,j]
+                cjj = vga[j,j]
+
+                dcij = - 1 / sqrt(cii * cjj - cij**2)
+                tmp = -dcij * cij / 2
+                dcii = tmp / cii
+                dcjj = tmp / cjj
+
+                a = tet.Class[t3m.comp(angle_edge)].Index
+
+                for length_edge, (m, n) in _OneSubsimplicesWithVertexIndices:
+                    l = tet.Class[length_edge].Index
+                    
+                    result[a, l] += (
+                        dcij * _cofactor_derivative(
+                            cofactor_matrices, i, j, m, n) +
+                        dcii * _cofactor_derivative(
+                            cofactor_matrices, i, i, m, n) +
+                        dcjj * _cofactor_derivative(
+                            cofactor_matrices, j, j, m, n))
+        return result
+
+    def full_rank_jacobian_submatrix(self):
+        return self.jacobian().matrix_from_rows_and_columns(
+            self.exact_edges, self.var_edges)
+
+    def derivative_of_single_dihedral_angle(self, tetIndex, i, j):
+        """
+        Gives the derivative of the single dihedral angle between face i and j
+        of tetrahedron tetIndex with respect to the edge parameters.
+        """
+        
+        s = len(self.mcomplex.Edges)
+        result = vector(self.vertex_gram_matrices[0].base_ring(), s)
+        
+        tet = self.mcomplex.Tetrahedra[tetIndex]
+
+        cofactor_matrices = _cofactor_matrices_for_submatrices(
+            self.vertex_gram_matrices[tetIndex])
+        vga = self.vertex_gram_adjoints[tetIndex]
+
+        cii = vga[i,i]
+        cij = vga[i,j]
+        cjj = vga[j,j]
+
+        dcij = - 1 / sqrt(cii * cjj - cij**2)
+        tmp = -dcij * cij / 2
+        dcii = tmp / cii
+        dcjj = tmp / cjj
+
+        for length_edge, (m, n) in _OneSubsimplicesWithVertexIndices:
+            l = tet.Class[length_edge].Index
+                    
+            result[l] += (
+                dcij * _cofactor_derivative(
+                    cofactor_matrices, i, j, m, n) +
+                dcii * _cofactor_derivative(
+                    cofactor_matrices, i, i, m, n) +
+                dcjj * _cofactor_derivative(
+                    cofactor_matrices, j, j, m, n))
+
+        return result
+        
+    def pick_exact_and_var_edges(self):
+        num_edges = len(self.mcomplex.Edges)
+        num_verts = len(self.mcomplex.Vertices)
+
+        J = self.jacobian().change_ring(RealDoubleField())
+
+        self.exact_edges, self.var_edges = _find_rows_and_columns_for_full_rank_submatrix(
+            J, num_edges - 3 * num_verts)
+       
+    def pgl2_matrix_for_edge(self, e):
+        """
+        e is a TruncatedComplex.Edge
+        """
+
+        RF = self.vertex_gram_matrices[0].base_ring()
+        CF = RF.complex_field()
+
+        if e.subcomplex_type == 'alpha':
+            tet_index, perm = e.tet_and_perm
+            v = self.vertex_gram_matrices[tet_index][perm[0], perm[1]]
+            return matrix(CF, [[0, (v**2 - 1).sqrt() - v], [1, 0]])
+
+        if e.subcomplex_type == 'beta':
+            etaHalf = self._compute_eta(e.tet_and_perm) / 2
+            c = etaHalf.cos()
+            s = etaHalf.sin()
+
+            return matrix(CF, [[-c, s], [s, c]])
+
+        if e.subcomplex_type == 'gamma':
+            theta = self._compute_theta(e.tet_and_perm)
+            return matrix(CF, [[(theta * sage.all.I).exp(), 0],[0,1]])
+
+        raise Exception("Unsupported edge type")
+
+    def so3_matrix_for_edge(self, e):
+        """
+        e is a TruncatedComplex.Edge
+        """
+        if e.subcomplex_type == 'beta':
+            eta = self._compute_eta(e.tet_and_perm)
+            c = eta.cos()
+            s = eta.sin()
+
+            return matrix([[-c, 0, s], [0, -1, 0], [s, 0, c]])
+
+        if e.subcomplex_type == 'gamma':
+            theta = self._compute_theta(e.tet_and_perm)
+            return HyperbolicStructure.so3_matrix_for_z_rotation(theta)
+
+        raise Exception("Unsupported edge type")
+        
+    def pgl2_matrix_for_path(self, p):
+        if p:
+            return prod([self.pgl2_matrix_for_edge(e) for e in p[::-1]])
+        else:
+            RF = self.vertex_gram_matrices[0].base_ring()
+            CF = RF.complex_field()
+            return matrix.identity(CF, 2)
+
+    def so3_matrix_for_path(self, p):
+        if p:
+            return prod([self.so3_matrix_for_edge(e) for e in p[::-1]])
+        else:
+            RF = self.vertex_gram_matrices[0].base_ring()
+            return matrix.identity(RF, 3)
+
+    @staticmethod
+    def so3_matrix_for_z_rotation(angle):
+        c = angle.cos()
+        s = angle.sin()
+        
+        return matrix([[c, -s, 0], [s, c, 0], [0, 0, 1]])
+  
+    @staticmethod
+    def so3_matrix_and_derivative_for_z_rotation(angle):
+        c = angle.cos()
+        s = angle.sin()
+        
+        return (
+            matrix([[ c, -s, 0], [s,  c, 0], [0, 0, 1]]),
+            matrix([[-s, -c, 0], [c, -s, 0], [0, 0, 0]]))
+
+    def _compute_theta(self, tet_and_perm):
+        tet_index, perm = tet_and_perm
+        angle = self.dihedral_angles[tet_index][perm[2]][perm[3]]
+        
+        if perm.sign() == 0:
+            return -angle
+        else:
+            return  angle
+
+    def _compute_eta(self, tet_and_perm):
+        tet_index, perm = tet_and_perm
+        vertex_gram_matrix = self.vertex_gram_matrices[tet_index]
+        vij = vertex_gram_matrix[perm[0], perm[1]]
+        vik = vertex_gram_matrix[perm[0], perm[2]]
+        vjk = vertex_gram_matrix[perm[1], perm[2]]
+        
+        t = (vij * vik + vjk) / ( (vij ** 2 - 1) * (vik ** 2 - 1) ).sqrt()
+
+        return t.arccos()
+
+def _compute_vertex_gram_matrix(tet, edge_lengths):
+    def entry(i, j):
+        if i == j:
+            return -1
+        e = t3m.ZeroSubsimplices[i] | t3m.ZeroSubsimplices[j]
+        edge = tet.Class[e]
+        return edge_lengths[edge.Index]
+
+    return matrix([ [ entry(i,j) for j in range(4) ] for i in range(4) ])
+        
+def _dihedral_angle(vertex_gram_adjoint, i, j):
+    if i == j:
+        return 0
+    
+    cij = vertex_gram_adjoint[i][j]
+    cii = vertex_gram_adjoint[i][i]
+    cjj = vertex_gram_adjoint[j][j]
+
+    ciicjj = cii * cjj
+    if not (ciicjj > 0):
+        raise BadDihedralAngleError("cii*cjj not positive")
+
+    t = cij / ciicjj.sqrt()
+    if not (abs(t) < 1):
+        raise BadDihedralAngleError("|cos(angle)| not < 1")
+
+    return t.arccos()
+
+def _find_max(m, rows_left, cols_left):
+    v = -1
+    for r in rows_left:
+        for c in cols_left:
+            a = abs(m[r,c])
+            if a > v:
+                v, row, col = a, r, c
+
+    return row, col
+
+def _find_rows_and_columns_for_full_rank_submatrix(m, expected_rank):
+    num_rows, num_cols = m.dimensions()
+
+    rows_left = set(range(num_rows))
+    cols_left = set(range(num_cols))
+    
+    for i in range(expected_rank):
+        row, col = _find_max(m, rows_left, cols_left)
+
+        rows_left.remove(row)
+        cols_left.remove(col)
+
+        for r in rows_left:
+            m.add_multiple_of_row(   r, row, -m[r,   col] / m[row, col])
+        for c in cols_left:
+            m.add_multiple_of_column(c, col, -m[row, c  ] / m[row, col])
+
+    return ([row for row in range(num_rows) if row not in rows_left],
+            [col for col in range(num_cols) if col not in cols_left])
+
+
+def _cofactor_matrices_for_submatrices(m):
+    def cofactor_matrix(r, c):
+        submatrix = m.matrix_from_rows_and_columns(
+            [k for k in range(4) if k != r],
+            [k for k in range(4) if k != c])
+        return submatrix.adjugate().transpose() * (-1) ** (r + c)
+
+    return [[ cofactor_matrix(r, c) for c in range(4) ] for r in range(4) ]
+            
+def _one_cofactor_derivative(cofactor_matrices, i, j, m, n):
+    if i == m or j == n:
+        return 0
+    return cofactor_matrices[i][j][
+        m if m < i else m - 1, n if n < j else n - 1]
+
+def _cofactor_derivative(cofactor_matrices, i, j, m, n):
+    return (
+        _one_cofactor_derivative(cofactor_matrices, i, j, m, n) +
+        _one_cofactor_derivative(cofactor_matrices, i, j, n, m))
+
+_OneSubsimplicesWithVertexIndices = [
+    (oneSubsimplex, [ index
+                      for index, zeroSubsimplex
+                      in enumerate(t3m.ZeroSubsimplices)
+                      if zeroSubsimplex & oneSubsimplex ])
+    for oneSubsimplex in t3m.OneSubsimplices ]

snappy/dev/vericlosed/krawczykCertifiedEdgeLengthsEngine.py

@@ -0,0 +1,165 @@
+from .hyperbolicStructure import *
+from .verificationError import *
+
+from sage.all import RealDoubleField, RealIntervalField, vector, matrix, pi
+
+__all__ = ['KrawczykCertifiedEdgeLengthsEngine']
+
+class KrawczykCertifiedEdgeLengthsEngine:
+    """
+    Performs Step I of the algorithm.
+
+    The input is an instance of HyperbolicStructure where the unverified edge
+    lengths are in SageMath's RealDoubleField or RealField - and where the
+    exact_edges (E^= in the notation of the paper) and var_edges (E^var) are
+    set (using HyperbolicStructure.pick_exact_and_var_edges).
+
+    The output are intervals (in RealIntervalField) for the edge lengths
+    verified to contain a solution to the equations indexed by exact_edges.
+    To obtain an instance of HyperbolicStructure based on these edge lengths,
+    call
+    KrawczykCertifiedEdgeLengthsEngine.partially_verified_hyperbolic_structure
+    
+    Note: We say edge lengths when we really mean the edge parameter, i.e.,
+    -cosh(hyperbolic length of an edge).
+    """
+
+    
+    def __init__(self, approx_hyperbolic_structure, bits_prec = 53):
+        
+        if not (approx_hyperbolic_structure.exact_edges and
+                approx_hyperbolic_structure.var_edges):
+            raise Exception(
+                "Did not pick exact/var edges: "
+                "call HyperbolicStructure.pick_exact_and_var_edges.")
+
+        self.mcomplex    = approx_hyperbolic_structure.mcomplex
+        self.exact_edges = approx_hyperbolic_structure.exact_edges
+        self.var_edges   = approx_hyperbolic_structure.var_edges
+        self.bits_prec   = bits_prec
+        self.RIF   = RealIntervalField(bits_prec)
+        self.twoPi = self.RIF(2 * pi)
+    
+        self.initial_edge_lengths = vector(
+            [ self.RIF(e) for  e in approx_hyperbolic_structure.edge_lengths ])
+
+        self.approx_inverse = (
+                  approx_hyperbolic_structure.full_rank_jacobian_submatrix()
+                                             .change_ring(RealDoubleField())
+                                             .inverse()
+                                             .change_ring(self.RIF))
+        
+        self.identity = matrix.identity(self.RIF, len(self.var_edges))
+
+        self.certified_edge_lengths = None
+
+    def krawczyk_iteration(self, edge_lengths):
+
+        try:
+            h = HyperbolicStructure(
+                self.mcomplex, edge_lengths, self.exact_edges, self.var_edges)
+        except BadDihedralAngleError as e:
+            raise KrawczykFailedWithBadDihedralAngleError("During iteration", e)
+
+        error = [ h.angle_sums[e] - self.twoPi for e in self.var_edges ]
+        jacobian = h.full_rank_jacobian_submatrix()
+
+        diffs = vector(
+            self.RIF,
+            [ edge_lengths[var_edge] - self.initial_edge_lengths[var_edge]
+              for var_edge in self.var_edges])
+
+        var_edge_lengths = (
+            self.first_term
+            + (self.identity - self.approx_inverse * jacobian) * diffs)
+        
+        result = [ edge_length for edge_length in edge_lengths ]
+        for var_edge, edge_length in zip(self.var_edges, var_edge_lengths):
+            result[var_edge] = edge_length
+
+        return vector(self.RIF, result)
+
+    @staticmethod
+    def interval_vector_union(vecA, vecB):
+        """
+        Given two vectors of intervals, return the vector of their unions,
+        i.e., the smallest interval containing both intervals.
+        """
+
+        return vector([ a.union(b) for a, b in zip(vecA, vecB) ])
+
+    @staticmethod
+    def interval_vector_is_contained_in(vecA, vecB):
+        """
+        Given two vectors of intervals, return whether the first one
+        is contained in the second one.  Examples::
+
+            sage: RIF = RealIntervalField(80)
+            sage: CIF = ComplexIntervalField(80)
+            sage: box = CIF(RIF(-1,1),RIF(-1,1))
+            sage: a = [ CIF(0.1), CIF(1) + box ]
+            sage: b = [ CIF(0) + box, CIF(1) + 2 * box ]
+            sage: c = [ CIF(0), CIF(1) + 3 * box ]
+
+            sage: KrawczykCertifiedShapesEngine.interval_vector_is_contained_in(a, b)
+            True
+            sage: KrawczykCertifiedShapesEngine.interval_vector_is_contained_in(a, c)
+            False
+            sage: KrawczykCertifiedShapesEngine.interval_vector_is_contained_in(b, a)
+            False
+            sage: KrawczykCertifiedShapesEngine.interval_vector_is_contained_in(b, c)
+            False
+            sage: KrawczykCertifiedShapesEngine.interval_vector_is_contained_in(c, a)
+            False
+            sage: KrawczykCertifiedShapesEngine.interval_vector_is_contained_in(c, b)
+            False
+        """
+        return all([(a in b) for a, b in zip(vecA, vecB)])
+
+    def expand_until_certified(self, verbose = False):
+        try:
+            h = HyperbolicStructure(
+                self.mcomplex, self.initial_edge_lengths,
+                self.exact_edges, self.var_edges)
+        except BadDihedralAngleError as e:
+            raise KrawczykFailedWithBadDihedralAngleError("When preparing for certification", e)
+            
+        error_at_initial_edge_lengths = vector(
+            self.RIF,
+            [ h.angle_sums[e] - self.twoPi for e in self.var_edges ])
+
+        self.first_term = (vector(self.RIF,[self.initial_edge_lengths[c] for c in self.var_edges])
+                           - self.approx_inverse * error_at_initial_edge_lengths)
+
+        edge_lengths = self.initial_edge_lengths
+
+        num_iterations = (25 if self.bits_prec > 53 else 11)
+
+        for i in range(num_iterations + 1):
+            old_edge_lengths = edge_lengths
+
+            edge_lengths = self.krawczyk_iteration(edge_lengths)
+
+            if KrawczykCertifiedEdgeLengthsEngine.interval_vector_is_contained_in(
+                    edge_lengths, old_edge_lengths):
+                self.certified_edge_lengths = edge_lengths
+                
+                if verbose:
+                    print("Certified in iteration", i)
+                
+                return True
+
+            edge_lengths = KrawczykCertifiedEdgeLengthsEngine.interval_vector_union(
+                edge_lengths, old_edge_lengths)
+
+        raise KrawczykFailedToFinishError("Failed after iterations", num_iterations)
+    
+    def partially_verified_hyperbolic_structure(self, verbose = False):
+        
+        self.expand_until_certified(verbose)
+
+        return HyperbolicStructure(
+            self.mcomplex,
+            self.certified_edge_lengths,
+            self.exact_edges,
+            self.var_edges)