def generate_neighbour_isoSigs(self, ceiling, floor): # tri, angle = self.getTriang() tri, angle = self.tri, self.angle num_tetrahedra = tri.countTetrahedra() assert num_tetrahedra <= ceiling assert num_tetrahedra >= floor if num_tetrahedra < ceiling: for face_index in range(tri.countTriangles()): tri_copy = regina.Triangulation3(tri) angle_copy = angle[:] output = twoThreeMove(tri_copy, angle_copy, face_index) if output != False: tri_new, angle_new = output self.neighbour_moves_up_faces[isosig_from_tri_angle( tri_new, angle_new)] = 'f' + str(face_index) self.neighbour_moves_up_tri_angles[isosig_from_tri_angle( tri_new, angle_new)] = (tri_new, angle_new) if num_tetrahedra > floor: for edge_index in range(tri.countEdges()): tri_copy = regina.Triangulation3(tri) angle_copy = angle[:] output = threeTwoMove(tri_copy, angle_copy, edge_index) if output != False: tri_new, angle_new = output self.neighbour_moves_down_edges[isosig_from_tri_angle( tri_new, angle_new)] = 'e' + str(edge_index) self.neighbour_moves_down_tri_angles[isosig_from_tri_angle( tri_new, angle_new)] = (tri_new, angle_new) self.neighbour_moves_tri_angles = { **self.neighbour_moves_up_tri_angles, **self.neighbour_moves_down_tri_angles } ## union of the dictionaries
def generate_neighbour_isoSigs(self, ceiling, floor): # tri, angle = self.getTriang() tri, angle, branch = self.tri, self.angle, self.branch num_tetrahedra = tri.countTetrahedra() assert num_tetrahedra <= ceiling assert num_tetrahedra >= floor if num_tetrahedra < ceiling: for face_index in range(tri.countTriangles()): # print('face_index', face_index) tri_copy = regina.Triangulation3(tri) angle_copy = angle[:] output_taut = taut_pachner.twoThreeMove( tri_copy, angle_copy, face_index) # print('output_taut', output_taut) tri_copy2 = regina.Triangulation3(tri) branch_copy = branch[:] output_branch = branched_pachner.twoThreeMove( tri_copy2, branch_copy, face_index) # print('output_branch', output_branch) if output_taut != False and output_branch != False: tri_new, angle_new = output_taut _, branch_new_list = output_branch for branch_new in branch_new_list: new_isosig = isosig_from_tri_angle_branch( tri_new, angle_new, branch_new) # print('new_isosig', new_isosig) self.neighbour_moves_up_faces[new_isosig] = 'f' + str( face_index) self.neighbour_moves_up_tri_angle_branches[ new_isosig] = (tri_new, angle_new, branch_new) if num_tetrahedra > floor: # print('now do threeTwoMove') for edge_index in range(tri.countEdges()): # print('edge_index', edge_index) tri_copy = regina.Triangulation3(tri) angle_copy = angle[:] output_taut = taut_pachner.threeTwoMove( tri_copy, angle_copy, edge_index) # print('output_taut', output_taut) tri_copy2 = regina.Triangulation3(tri) branch_copy = branch[:] output_branch = branched_pachner.threeTwoMove( tri_copy2, branch_copy, edge_index) # print('output_branch', output_branch) if output_taut != False and output_branch != False: tri_new, angle_new = output_taut _, branch_new = output_branch new_isosig = isosig_from_tri_angle_branch( tri_new, angle_new, branch_new) # print('new_isosig', new_isosig) self.neighbour_moves_down_edges[new_isosig] = 'e' + str( edge_index) self.neighbour_moves_down_tri_angle_branches[ new_isosig] = (tri_new, angle_new, branch_new) self.neighbour_moves_tri_angle_branches = { **self.neighbour_moves_up_tri_angle_branches, **self.neighbour_moves_down_tri_angle_branches } ## union of the dictionaries
def main(): # for i in range(4): # print(i) # # tri, angle = isosig_to_tri_angle('cPcbbbiht_12') # sigs = ['dLQacccjsnk_200', 'dLQbccchhfo_122','dLQbccchhsj_122'] # for sig in sigs: # print(sig) # tri, angle = isosig_to_tri_angle(sig) # for branch in all_branched_surfaces(tri): # print(lex_smallest_branched_surface(tri, branch)) sig = 'dLQacccjsnk_200' for i in range(6): # print(i) tri, angle = isosig_to_tri_angle(sig) tri_original = regina.Triangulation3(tri) #copy out = twoThreeMove(tri, [4, 11, 0], i, return_edge=True) if out != False: tri, possible_branches, edge_num = out # print('possible_branches', possible_branches) # print('all branches', all_branched_surfaces(tri)) tri, branch = threeTwoMove(tri, possible_branches[0], edge_num) all_isoms = tri.findAllIsomorphisms(tri_original) all_branches = [ apply_isom_to_branched_surface(branch, isom) for isom in all_isoms ] assert [4, 11, 0] in all_branches
def num_veering_structs(M, angles=None, use_flipper=True): """ Tries to count them (in a very naive way). Tries to eliminate overcounting due to symmetries (in reduced_angles) but will fail if one of the symmetries is hidden by retriangulation. If use_flipper = False then we get a (true) lower bound, since then it only counts veering structures on the given triangulation. """ if angles == None: angles = reduced_angles(M) tri = regina.Triangulation3(M) for angle in angles: if not is_taut(tri, angle): return None for angle in angles: if not (is_veering(tri, angle) or is_layered(tri, angle)): return None total = 0 for angle in angles: if is_veering(tri, angle): total = total + 1 elif use_flipper: assert is_layered(tri, angle) print(M.name(), angle, "needs flipper") try: if not has_internal_singularities(tri, angle): total = total + 1 except: print("flipper failed") return total
def fix_orientations(tri, angle, return_isom=False): """ Fix the orientations of the tetrahedra in triangulation so that they are consistently oriented. We choose how to flip each tetrahedron so that the angle structure list does not change. If return_isom, return the isomorphism from the original tri to the fixed orientations tri """ orig_tri = regina.Triangulation3(tri) old_orientations = find_orientations(tri) swaps = [] for i, orientation in enumerate(old_orientations): if orientation == -1: swaps.append( reverse_tet_orientation(tri, tri.tetrahedron(i), angle[i])) else: swaps.append(regina.Perm4()) ## identity if return_isom: out_isom = regina.Isomorphism3.identity(len(swaps)) for i, p in enumerate(swaps): out_isom.setFacetPerm(i, p) return out_isom ### Regina 6 didn't let us build the isom directly from perms in python. Regina 7 does, using setFacetPerm ### old: # all_isoms = orig_tri.findAllIsomorphisms(tri) ### we will be order two, so we dont care which way this goes # for isom in all_isoms: # if not moves_tetrahedra(isom): # for i in range(tri.countTetrahedra()): # assert swaps[i] == isom.facetPerm(i) # assert isom == out_isom # return isom assert False ## should never get here
def go_deeper(tri, branch): for i in range(tri.countTriangles()): tri_copy = regina.Triangulation3(tri) #copy branch_copy = branch[:] out = twoThreeMove(tri_copy, branch_copy, i) if out != False: tri_copy2, possible_branches = out return tri_copy2, possible_branches[0]
def main(): tri, angle = isosig_to_tri_angle('jLLAvQQbcdeihhiihtsfxedxhdt_201021201') # tri, angle = isosig_to_tri_angle('cPcbbbiht_12') for i in range(tri.countTriangles()): print('triangle_num', i) tri2 = regina.Triangulation3(tri) angle2 = angle[:] tri3, angle3, edge_num = twoThreeMove(tri2, angle2, i, return_edge = True) print('angle3', angle3, 'edge_num', edge_num) threeTwoMove(tri3, angle3, edge_num)
def do_all_veering_n_surgeries(tri, angle, n=1): # apply veering mobius dehn surgery n times to all Mobius strips in tri, print the results out = [] print(("mob strip faces: " + str(get_mobius_strip_indices(tri)))) for face_num in get_mobius_strip_indices(tri): print(("face_num", face_num)) tri2 = regina.Triangulation3(tri) # make a copy tri_surg, angle_surg, face_num_surg = veering_n_mobius_dehn_surgery( tri2, angle, face_num, n) sig = isosig_from_tri_angle(tri_surg, angle_surg) print(sig) out.append(sig) return out
def can_deal_with_reduced_angles(M, report=False): """ Returns True if we can deal with all of the reduced angles. """ angles = reduced_angles(M) tri = regina.Triangulation3(M) if report: nv = num_veering_structs(M, angles=angles, use_flipper=False) return all( can_deal_with_reduced_angle(tri, angle) for angle in angles), len(angles), nv else: return all(can_deal_with_reduced_angle(tri, angle) for angle in angles)
def leading_trailing_deformations(M): tri = regina.Triangulation3(M) num_tet = tri.countTetrahedra() out = [] for e in tri.edges(): defm = [0] * (3 * num_tet) for i in range(e.degree()): emb = e.embedding(i) tet_num = emb.simplex().index() v0, v1, v2 = emb.vertices()[0], emb.vertices()[1], emb.vertices( )[2] a = unsorted_vert_pair_to_edge_pair[(v0, v2)] b = unsorted_vert_pair_to_edge_pair[(v1, v2)] defm[3 * tet_num + a] += 1 defm[3 * tet_num + b] -= 1 out.append(vector(defm)) return out
def is_fibered(snappy_name, tries=1000, with_data=False): """ Given an snappy_name, tries to find a layered transverse taut triangulation for the manifold via random search. """ sigs = get_many_sigs(snappy_name, tries) for sig in sigs: T = regina.Triangulation3(sig) T.orient() angle_strs = list(regina.AngleStructures.enumerate(T, True)) angle_strs = [ taut_regina_angle_struct_to_taut_struct(angle_str) for angle_str in angle_strs ] for angle in angle_strs: # we are not interested in semi-fibered manifolds so: if is_transverse_taut(T, angle) and is_layered(T, angle): if with_data: return (True, T.isoSig(), angle) return True return False
def reduced_angles(M): """ Given a snappy manifold M, compute the reduced charges, convert to angle structures, remove repeated structures (using symmetries of the triangulation), remove non-trivial structures (in cohomology), and return what remains. """ charges = reduced_charges(M) tri = regina.Triangulation3(M) angles = [charge_to_angle(c) for c in charges] # remove symmetries lex_angles = [lex_smallest_angle_structure(tri, angle) for angle in angles] angles = [] for angle in lex_angles: if angle not in angles: angles.append(angle) # remove the angles that flip a triangle over angles = [ angle for angle in angles if is_trivial_in_cohomology(tri, angle) ] return angles
def generate_neighbour_isoSigs(self, ceiling, floor): # tri, angle = self.getTriang() tri, angle, branch = self.tri, self.angle, self.branch num_tetrahedra = tri.countTetrahedra() assert num_tetrahedra <= ceiling assert num_tetrahedra >= floor if num_tetrahedra < ceiling: for face_index in range(tri.countTriangles()): ### only go this way if it expands the drilled cusp face = tri.triangles()[face_index] embed0 = face.embedding(0) tet0 = embed0.simplex() tet_0_face_num = embed0.face() embed1 = face.embedding(1) tet1 = embed1.simplex() tet_1_face_num = embed1.face() if (tet0.vertex(tet_0_face_num).index() == self.drilled_cusp_index) or ( tet1.vertex(tet_1_face_num).index() == self.drilled_cusp_index): tri_copy = regina.Triangulation3(tri) angle_copy = angle[:] branch_copy = branch[:] output = twoThreeMove(tri_copy, face_index, angle=angle_copy, branch=branch_copy, return_vertex_perm=True) # print('2-3', face_index, output) if output != False: tri_new, angle_new, branches_new, vertex_perm = output drilled_cusp_index_new = vertex_perm[ self.drilled_cusp_index] for branch_new in branches_new: sig_new = isosig_from_tri_angle_branch( tri_new, angle_new, branch_new) self.neighbour_moves_up_faces[sig_new] = 'f' + str( face_index) self.neighbour_moves_up_tri_angle_branch[ sig_new] = (tri_new, angle_new, branch_new, drilled_cusp_index_new) if num_tetrahedra > floor: for edge_index in range(tri.countEdges()): ### only go this way if it expands the drilled cusp edge = tri.edges()[edge_index] if (edge.vertex(0).index() != self.drilled_cusp_index) and ( edge.vertex(1).index() != self.drilled_cusp_index): tri_copy = regina.Triangulation3(tri) angle_copy = angle[:] branch_copy = branch[:] output = threeTwoMove(tri_copy, edge_index, angle=angle_copy, branch=branch_copy, return_vertex_perm=True) if output != False: tri_new, angle_new, branch_new, vertex_perm = output drilled_cusp_index_new = vertex_perm[ self.drilled_cusp_index] sig_new = isosig_from_tri_angle_branch( tri_new, angle_new, branch_new) self.neighbour_moves_down_edges[sig_new] = 'e' + str( edge_index) self.neighbour_moves_down_tri_angle_branch[sig_new] = ( tri_new, angle_new, branch_new, drilled_cusp_index_new) self.neighbour_moves_tri_angle_branch = { **self.neighbour_moves_up_tri_angle_branch, **self.neighbour_moves_down_tri_angle_branch } ## union of the dictionaries
def threeTwoMove(tri, branch, edge_num, return_triangle=False): """Apply a 3-2 move to a triangulation with a branched surface, if possible. If perform = False, returns if the move is possible. modifies tri, returns (tri, branch) for the performed move""" ### note if this function does not return False, then there is only one ### possible branch so we just return it rather than a list # assert is_branched(tri, branch) assert has_non_sing_semiflow(tri, branch) edge = tri.edge(edge_num) if edge.degree() != 3: return False tets = [] tet_nums = [] vertices = [] for i in range(3): embed = edge.embedding(i) tets.append(embed.simplex()) tet_nums.append(tets[i].index()) vertices.append(embed.vertices()) if len(set([tet.index() for tet in tets])) != 3: return False ### tetrahedra must be distinct ### check we do the same as regina... tri2 = regina.Triangulation3(tri) ## make a copy tri2.pachner(tri2.edge(edge_num)) ## record the tetrahedra and gluings adjacent to the tets gluings = [] for i in range(3): tet_gluings = [] for j in range(2): tet_gluings.append([ tets[i].adjacentTetrahedron(vertices[i][j]), tets[i].adjacentGluing(vertices[i][j]) ]) gluings.append(tet_gluings) for i in range(3): assert tets[i].adjacentTetrahedron(vertices[i][2]) == tets[ (i + 1) % 3] ### The edge embeddings should be ordered this way... large_edges = [] ### record large edge info for the outer faces for i in range(3): this_tet_large_edges = [] for j in range(2): this_tet_large_edges.append( large_edge_of_face(branch[tets[i].index()], vertices[i][j])) large_edges.append(this_tet_large_edges) ### add new tetrahedra new_tets = [] for i in range(2): new_tets.append(tri.newTetrahedron()) ### glue across face new_tets[0].join(3, new_tets[1], regina.Perm4(0, 2, 1, 3)) ### replace mapping info with corresponding info for the 2 tet. Self gluings will be annoying... ### write vertices[i][j] as vij ### tets[0] new_tet1 ### _________ _________ ### ,'\`.v00,'/`. ,'\ /`. ### ,' \ `.' / `. ,' \ 3 / `. ### ,' v10\ | /v20 `. ,' \ / `. ### /|\ \|/ /|\ / \ \ / / \ ### / | \ * / | \ / \ * / \ ### v12/ | \..... | ...../ | \v23 / 1 _\..... | ...../_ 2 \ ### / ,' / * \ `. \ /_--"" / * \ ""--_\ ### \`.| /v03 /|\ v02\ |,'/ `. \`. 2 / / \ \ 1 ,'/ ### \ `./ / | \ \,' / ----} \ `./ / \ \,' / ### \|/`. / | \ ,'\|/ ,' \ /`. / 0 \ ,'\ / ### \ `. / | \ ,' / \ `. / \ ,' / ### \ * v13|v22 * / \ `---------' / ### \ \ | / / \ \ / / ### \ \ | / / \ \ 0 / / ### \ \ | / / \ \ / / ### tets[1] \ \|/ / tets[2] \ \ / / ### \ * / \ * / new_tet0 ### \..v01../ \...|.../ ### \`.|.'/ \ | / ### v11\ | /v21 \ 3 / ### \|/ \|/ ### * * # permutations taking the vertices for a face of the 2-tet ball to the # vertices of the same face for the 3-tet ball # these should be even in order to preserve orientability. # perms = [[regina.Perm4( vertices[0][0], vertices[0][2], vertices[0][3], vertices[0][1] ), ### opposite v00 # regina.Perm4( vertices[0][1], vertices[0][3], vertices[0][2], vertices[0][0] ) ### opposite v01 # ], # [regina.Perm4( vertices[1][3], vertices[1][0], vertices[1][2], vertices[1][1] ), ### opposite v10 # regina.Perm4( vertices[1][3], vertices[1][2], vertices[1][1], vertices[1][0] ) ### opposite v11 # ], # [regina.Perm4( vertices[2][2], vertices[2][3], vertices[2][0], vertices[2][1] ), ### opposite v20 # regina.Perm4( vertices[2][2], vertices[2][1], vertices[2][3], vertices[2][0] ) ### opposite v21 # ] # ] perms = [ [ vertices[0] * regina.Perm4(0, 2, 3, 1), ### opposite v00 vertices[0] * regina.Perm4(1, 3, 2, 0) ### opposite v01 ], [ vertices[1] * regina.Perm4(3, 0, 2, 1), ### opposite v10 vertices[1] * regina.Perm4(3, 2, 1, 0) ### opposite v11 ], [ vertices[2] * regina.Perm4(2, 3, 0, 1), ### opposite v20 vertices[2] * regina.Perm4(2, 1, 3, 0) ### opposite v21 ] ] for i in range(3): for j in range(2): gluing = gluings[i][j] if gluing != None: if gluing[0] not in tets: ### not a self gluing gluing[1] = gluing[1] * perms[i][j] else: i_other = tets.index(gluing[0]) otherfacenum = gluing[1][vertices[i][j]] j_other = [vertices[i_other][k] for k in range(4)].index(otherfacenum) assert gluings[i_other][j_other][0] == tets[i] assert gluings[i_other][j_other][1].inverse( ) == gluings[i][j][1] gluings[i_other][ j_other] = None ### only do a self gluing from one side gluing[0] = new_tets[ j_other] ### j refers to the vertex on the same 3 side gluing[1] = perms[i_other][j_other].inverse( ) * gluing[1] * perms[i][j] ### unglue three tetrahedra for tet in tets: tet.isolate() ### remove the tetrahedra for tet in tets: tri.removeSimplex(tet) ### make the gluings on the boundary of the new ball for i in range(3): for j in range(2): if gluings[i][j] != None: if j == 0 or i == 0: assert new_tets[j].adjacentTetrahedron( i) == None ## not glued assert gluings[i][j][0].adjacentTetrahedron( gluings[i][j][1][i]) == None new_tets[j].join(i, gluings[i][j][0], gluings[i][j][1]) else: assert new_tets[j].adjacentTetrahedron( 3 - i) == None ## not glued assert gluings[i][j][0].adjacentTetrahedron( gluings[i][j][1][3 - i]) == None new_tets[j].join(3 - i, gluings[i][j][0], gluings[i][j][1]) ## swap 1 and 2 assert tri.isIsomorphicTo(tri2) assert tri.isOriented() # ### update the branched surface tet_nums.sort() branch.pop(tet_nums[2]) branch.pop(tet_nums[1]) branch.pop(tet_nums[0]) ## remove from the list in the correct order! ### update the branched surface ### for each of the two new tetrahedra, figure out what their outer face train tracks are large_edges_new = [] ### record large edge info for the outer faces for i in range(3): this_tet_large_edges_new = [] for j in range(2): new_large_edge = perms[i][j].inverse()[large_edges[i][j]] # assert new_large_edge != i ?? this_tet_large_edges_new.append(new_large_edge) large_edges_new.append(this_tet_large_edges_new) large_edges_new_transposed = [list(i) for i in zip(*large_edges_new)] branch0 = determine_possible_branch_given_three_faces( [0, 1, 2], large_edges_new_transposed[0]) branch1 = determine_possible_branch_given_three_faces( [0, 2, 1], large_edges_new_transposed[1]) if branch0 == None or branch1 == None: return False large_edge_for_new_tet0 = large_edge_of_face(branch0, 3) large_edge_for_new_tet1 = large_edge_of_face(branch1, 3) if large_edge_for_new_tet0 == large_edge_for_new_tet1: if large_edge_for_new_tet0 != 0: return False else: if large_edge_for_new_tet0 + large_edge_for_new_tet1 != 3: ### one must be 1, one must be 2 return False branch.extend([branch0, branch1]) # if not is_branched(tri, branch): if not has_non_sing_semiflow(tri, branch): return False if not return_triangle: return (tri, branch) else: return (tri, branch, new_tets[0].triangle(3).index())
def twoThreeMove(tri, branch, face_num, perform=True, return_edge=False): """Apply a 2-3 move to a triangulation with a branched surface, if possible. If perform = False, returns if the move is possible. If perform = True, modifies tri, returns (tri, possible_branches) for the performed move""" ### possible_branches is a list # assert is_branched(tri, branch) assert has_non_sing_semiflow(tri, branch) face = tri.triangle(face_num) embed0 = face.embedding(0) tet0 = embed0.simplex() tet_num0 = tet0.index() tet_0_face_num = embed0.face() vertices0 = embed0.vertices( ) # Maps vertices (0,1,2) of face to the corresponding vertex numbers of tet0 embed1 = face.embedding(1) tet1 = embed1.simplex() tet_num1 = tet1.index() tet_1_face_num = embed1.face() vertices1 = embed1.vertices( ) # Maps vertices (0,1,2) of face to the corresponding vertex numbers of tet1 if tet0 == tet1: ### Cannot perform a 2-3 move across a self-gluing return False ### are all moves valid for the branched surface? ### for now, lets assume yes ### check we do the same as regina... tri2 = regina.Triangulation3(tri) ## make a copy tri2.pachner(tri2.triangle(face_num)) ### We have to implement twoThreeMove ourselves. e.g. we do a 2-3 move to canonical fig 8 knot complement triangulation. ### All of the original tetrahedra are removed. I don't see any way to carry the angle structure through without knowing ### exactly how Ben's implementation works. ## record the tetrahedra and gluings adjacent to tet0 and tet1 tets = [tet0, tet1] vertices = [vertices0, vertices1] # print('2-3 vertices signs') # print([v.sign() for v in vertices]) gluings = [] for i in range(2): tet_gluings = [] for j in range(3): tet_gluings.append([ tets[i].adjacentTetrahedron(vertices[i][j]), tets[i].adjacentGluing(vertices[i][j]) ]) # if tets[i].adjacentTetrahedron(vertices[i][j]) in tets: # print('self gluing') gluings.append(tet_gluings) large_edges = [] ### record large edge info for the outer faces for i in range(2): this_tet_large_edges = [] for j in range(3): this_tet_large_edges.append( large_edge_of_face(branch[tets[i].index()], vertices[i][j])) large_edges.append(this_tet_large_edges) ### add new tetrahedra new_tets = [] for i in range(3): new_tets.append(tri.newTetrahedron()) ### glue around degree 3 edge for i in range(3): new_tets[i].join(2, new_tets[(i + 1) % 3], regina.Perm4(0, 1, 3, 2)) ### replace mapping info with corresponding info for the 3 tet. Self gluings will be annoying... ### write verticesi[j] as vij ### tet0 new_tet0 ### _________ _________ ### ,'\ /`. ,'\`. ,'/`. ### ,' \ v03 / `. ,' \ `0' / `. ### ,' \ / `. ,' \ | / `. ### / \ \ / / \ /|\ \|/ /|\ ### /v02\ * /v01\ / | \ * / | \ ### / _\..... | ...../_ \ / | 3\..... | ...../2 | \ ### /_--"" / * \ ""--_\ /2 ,' / * \ `. 3\ ### \`.v12/ / \ \v11,'/ `. \`.| / /|\ \ |,'/ ### \ `./ / \ \,' / ----} \ `./ / | \ \,' / ### \ /`. / v00 \ ,'\ / ,' \|/`. / | \ ,'\|/ ### \ `. / \ ,' / \ `. / | \ ,' / ### \ `---------' / \ * 3 | 2 * / ### \ \ / / \ \ | / / ### \ \ v10 / / new_tet1 \ \ | / / new_tet2 ### \ \ / / \ \ | / / ### \ \ / / \ \|/ / ### \ * / \ * / ### tet1 \...|.../ \...|.../ ### \ | / \`.|.'/ ### \v13/ \ 1 / ### \|/ \|/ ### * * # permutations taking the vertices for a face of the 3-tet ball to the # vertices of the same face for the 2-tet ball # these should be even in order to preserve orientability. # exactly one of vertices[0] and vertices[1] is even, but it seems to depend on the face. # perms = [[regina.Perm4( vertices[0][3], vertices[0][0], vertices[0][1], vertices[0][2] ), ### opposite v00 # regina.Perm4( vertices[0][3], vertices[0][1], vertices[0][2], vertices[0][0] ), ### opposite v01 # regina.Perm4( vertices[0][3], vertices[0][2], vertices[0][0], vertices[0][1] ) ### opposite v02 # ], # [regina.Perm4( vertices[1][0], vertices[1][3], vertices[1][1], vertices[1][2] ), ### opposite v10 # regina.Perm4( vertices[1][1], vertices[1][3], vertices[1][2], vertices[1][0] ), ### opposite v11 # regina.Perm4( vertices[1][2], vertices[1][3], vertices[1][0], vertices[1][1] ) ### opposite v12 # ] # ] perms = [ [ vertices[0] * regina.Perm4(3, 0, 1, 2), ### opposite v00 vertices[0] * regina.Perm4(3, 1, 2, 0), ### opposite v01 vertices[0] * regina.Perm4(3, 2, 0, 1) ### opposite v02 ], [ vertices[1] * regina.Perm4(0, 3, 1, 2), ### opposite v10 vertices[1] * regina.Perm4(1, 3, 2, 0), ### opposite v11 vertices[1] * regina.Perm4(2, 3, 0, 1) ### opposite v12 ] ] flip = perms[0][0].sign() == -1 if flip: #then all of the signs are wrong, switch 0 and 1 on input perms = [[p * regina.Perm4(1, 0, 2, 3) for p in a] for a in perms] # print('flip') # else: # print('no flip') # print('2-3 perms signs') # print([[p.sign() for p in a] for a in perms]) for i in range(2): for j in range(3): gluing = gluings[i][j] if gluing != None: if gluing[0] not in tets: ### not a self gluing gluing[1] = gluing[1] * perms[i][j] else: i_other = tets.index(gluing[0]) otherfacenum = gluing[1][vertices[i][j]] j_other = [vertices[i_other][k] for k in range(4)].index(otherfacenum) assert gluings[i_other][j_other][0] == tets[i] assert gluings[i_other][j_other][1].inverse( ) == gluings[i][j][1] gluings[i_other][ j_other] = None ### only do a self gluing from one side gluing[0] = new_tets[j_other] gluing[1] = perms[i_other][j_other].inverse( ) * gluing[1] * perms[i][j] ### unglue two tetrahedra tet0.isolate() tet1.isolate() ### remove the tetrahedra tri.removeSimplex(tet0) tri.removeSimplex(tet1) ### make the gluings on the boundary of the new ball for i in range(2): for j in range(3): if gluings[i][j] != None: if flip: new_tets[j].join(i, gluings[i][j][0], gluings[i][j][1]) else: new_tets[j].join(1 - i, gluings[i][j][0], gluings[i][j][1]) assert tri.isIsomorphicTo(tri2) assert tri.isOriented() ### update the branched surface ### for each of the three new tetrahedra, figure out what their outer face train tracks are large_edges_new = [] ### record large edge info for the outer faces for i in range(2): this_tet_large_edges_new = [] for j in range(3): new_large_edge = perms[i][j].inverse()[large_edges[i][j]] if flip: assert new_large_edge != i ### the face number cannot be the large vertex for that face else: assert new_large_edge != 1 - i this_tet_large_edges_new.append(new_large_edge) large_edges_new.append(this_tet_large_edges_new) candidate_branches = [] for j in range(3): if flip: candidate_branches.append( determine_possible_branch_given_two_faces( (0, 1), (large_edges_new[0][j], large_edges_new[1][j]))) else: candidate_branches.append( determine_possible_branch_given_two_faces( (1, 0), (large_edges_new[0][j], large_edges_new[1][j]))) ### update the branch structure, many possible ways tet_indices = [tet_num0, tet_num1] tet_indices.sort() branch.pop(tet_indices[1]) branch.pop(tet_indices[0]) ## remove from the list in the correct order! out = [] for cand0 in candidate_branches[0]: for cand1 in candidate_branches[1]: for cand2 in candidate_branches[2]: candidate = branch[:] + [cand0, cand1, cand2] # print('candidate', candidate) # if is_branched(tri, candidate): if has_non_sing_semiflow(tri, candidate): out.append(candidate) # assert len(out) > 0 ### this works if we check is_branched three lines above, but not if we check has_non_sing_semiflow if len( out ) == 0: ### with has_non_sing_semiflow instead, we might not get any return False if not return_edge: return (tri, out) else: return (tri, out, new_tets[0].edge(0).index())
def drill_midsurface_bdy(tri, angle): vt = veering_triangulation(tri, angle) veering_colours = vt.veering_colours ## "red" or "blue" tet_types = vt.tet_types ### "toggle", "red" or "blue" tet_vert_coors = vt.coorientations drilledTri = regina.Triangulation3() subtet_indices = [] subtet_addresses = [] num_toggles = tet_types.count("toggle") drilled_num_tet = 8 * num_toggles + 4 * (tri.countTetrahedra() - num_toggles) meridians = [] ### in each toggle, we record the meridians for the two boundary components we are drilling ### note that this repeats the same meridian many times - the construction here is purely local: it is much ### easier to figure out which are duplicates of which later for i in range(tri.countTetrahedra()): tet = tri.tetrahedron(i) first_subtet_index = drilledTri.countTetrahedra() if tet_types[i] == 'toggle': num_to_add = 8 else: num_to_add = 4 for j in range(num_to_add): drilledTri.newTetrahedron() subtet_indices.append( range(first_subtet_index, first_subtet_index + num_to_add)) ### glue sub-tetrahedra together. Note that some tetrahedra will be negatively oriented [(t0, t1), (b0, b1)] = get_top_and_bottom_nums(tet_vert_coors, i) this_tet_subtet_addresses = {} if tet_types[i] == 'toggle': ## first two subtetrahedra are top two, second two are bottom two, then the four side tetrahedra tet_t0, tet_t1 = drilledTri.tetrahedron( first_subtet_index), drilledTri.tetrahedron( first_subtet_index + 1) # tet_ti is opposite vertex bi tet_b0, tet_b1 = drilledTri.tetrahedron(first_subtet_index + 2), drilledTri.tetrahedron( first_subtet_index + 3) # tet_bi is opposite vertex ti tet_s00 = drilledTri.tetrahedron(first_subtet_index + 4) tet_s01 = drilledTri.tetrahedron(first_subtet_index + 5) tet_s10 = drilledTri.tetrahedron(first_subtet_index + 6) tet_s11 = drilledTri.tetrahedron(first_subtet_index + 7) # tet_sij meets vertices ti and bj ## keys are (vert not on face, vert not on edge), returns the subtet which meets the face, edge this_tet_subtet_addresses[(b0, b1)] = tet_t0 this_tet_subtet_addresses[(b1, b0)] = tet_t1 this_tet_subtet_addresses[(t0, t1)] = tet_b0 this_tet_subtet_addresses[(t1, t0)] = tet_b1 this_tet_subtet_addresses[(t1, b1)] = tet_s00 this_tet_subtet_addresses[(b1, t1)] = tet_s00 this_tet_subtet_addresses[(t1, b0)] = tet_s01 this_tet_subtet_addresses[(b0, t1)] = tet_s01 this_tet_subtet_addresses[(t0, b1)] = tet_s10 this_tet_subtet_addresses[(b1, t0)] = tet_s10 this_tet_subtet_addresses[(t0, b0)] = tet_s11 this_tet_subtet_addresses[(b0, t0)] = tet_s11 tet_t0.join(b0, tet_t1, regina.Perm4(b0, b1, b1, b0, t0, t0, t1, t1)) ## b0 <-> b1, t0 and t1 fixed tet_b0.join(t0, tet_b1, regina.Perm4(t0, t1, t1, t0, b0, b0, b1, b1)) ## t0 <-> t1, b0 and b1 fixed tet_s00.join(b0, tet_t1, regina.Perm4(t0, t0, b1, b1, t1, b0, b0, t1)) tet_s00.join(t0, tet_b1, regina.Perm4(b0, b0, t1, t1, b1, t0, t0, b1)) tet_s01.join(b1, tet_t0, regina.Perm4(t0, t0, b0, b0, t1, b1, b1, t1)) tet_s01.join(t0, tet_b1, regina.Perm4(b1, b1, t1, t1, b0, t0, t0, b0)) tet_s10.join(b0, tet_t1, regina.Perm4(t1, t1, b1, b1, t0, b0, b0, t0)) tet_s10.join(t1, tet_b0, regina.Perm4(b0, b0, t0, t0, b1, t1, t1, b1)) tet_s11.join(b1, tet_t0, regina.Perm4(t1, t1, b0, b0, t0, b1, b1, t0)) tet_s11.join(t1, tet_b0, regina.Perm4(b1, b1, t0, t0, b0, t1, t1, b0)) ### meridian around upper hole meridian = [0] * (3 * drilled_num_tet) meridian[3 * tet_t1.index() + unsorted_vert_pair_to_edge_pair[b0, t0]] = -1 meridian[3 * tet_s00.index() + unsorted_vert_pair_to_edge_pair[b1, t1]] = 1 meridian[3 * tet_b1.index() + unsorted_vert_pair_to_edge_pair[t0, t1]] = 1 meridian[3 * tet_s01.index() + unsorted_vert_pair_to_edge_pair[b0, t1]] = 1 meridian[3 * tet_t0.index() + unsorted_vert_pair_to_edge_pair[b1, t0]] = -1 meridians.append(meridian) ### meridian around lower hole - swap b with t everywhere. Note this also swaps s01 with s10 meridian = [0] * (3 * drilled_num_tet) meridian[3 * tet_b1.index() + unsorted_vert_pair_to_edge_pair[t0, b0]] = -1 meridian[3 * tet_s00.index() + unsorted_vert_pair_to_edge_pair[t1, b1]] = 1 meridian[3 * tet_t1.index() + unsorted_vert_pair_to_edge_pair[b0, b1]] = 1 meridian[3 * tet_s10.index() + unsorted_vert_pair_to_edge_pair[t0, b1]] = 1 meridian[3 * tet_b0.index() + unsorted_vert_pair_to_edge_pair[t1, b0]] = -1 meridians.append(meridian) else: ## fan # first two tetrahedra are the top and bottom tet_t, tet_b = drilledTri.tetrahedron( first_subtet_index), drilledTri.tetrahedron( first_subtet_index + 1) # second two tetrahedra are the sides, s0 meets vertex t0, s1 meets vertex t1 tet_s0, tet_s1 = drilledTri.tetrahedron(first_subtet_index + 2), drilledTri.tetrahedron( first_subtet_index + 3) # tet_types[i] == 'blue' this_tet_subtet_addresses[(b0, b1)] = tet_t this_tet_subtet_addresses[(b1, b0)] = tet_t this_tet_subtet_addresses[(t0, t1)] = tet_b this_tet_subtet_addresses[(t1, t0)] = tet_b ### if this is a blue fan tet then each side tet meet a blue edge # tet_types[i] could be 'blue' or 'red' ### find which bottom vertex, when linked to t0, gives an edge of the correct colour if vt.get_edge_between_verts_colour(i, (t0, b0)) == tet_types[i]: s0b = b0 ## bottom vert of s0 s1b = b1 ## bottom vert of s1 this_tet_subtet_addresses[(t0, b0)] = tet_s1 this_tet_subtet_addresses[(b0, t0)] = tet_s1 this_tet_subtet_addresses[(t1, b1)] = tet_s0 this_tet_subtet_addresses[(b1, t1)] = tet_s0 else: s0b = b1 ## bottom vert of s0 s1b = b0 ## bottom vert of s1 this_tet_subtet_addresses[(t0, b1)] = tet_s1 this_tet_subtet_addresses[(b1, t0)] = tet_s1 this_tet_subtet_addresses[(t1, b0)] = tet_s0 this_tet_subtet_addresses[(b0, t1)] = tet_s0 tet_s0.join(s0b, tet_t, regina.Perm4(t0, t0, s0b, t1, s1b, s1b, t1, s0b)) tet_s0.join(t0, tet_b, regina.Perm4(s0b, s0b, t0, s1b, t1, t1, s1b, t0)) tet_s1.join(s1b, tet_t, regina.Perm4(t1, t1, s1b, t0, s0b, s0b, t0, s1b)) tet_s1.join(t1, tet_b, regina.Perm4(s1b, s1b, t1, s0b, t0, t0, s0b, t1)) subtet_addresses.append(this_tet_subtet_addresses) ### now glue subtetrahedra from different original tetrahedra together ### fan tetrahedra only glue two of three subtetrahedra on each face. ### toggles glue one of their subfaces all the way through to the next toggle... unglued_flags = [] for f in range(tri.countTriangles()): for e in range(3): unglued_flags.append((f, e)) while unglued_flags != []: (f, e) = unglued_flags.pop() # print f,e face = tri.triangle(f) embed0 = face.embedding(0) embed1 = face.embedding(1) tet_index_0 = embed0.simplex().index() tet_index_1 = embed1.simplex().index() face0 = embed0.face() face1 = embed1.face() vertperm0 = embed0.vertices() vertperm1 = embed1.vertices() edge0 = vertperm0[e] edge1 = vertperm1[e] otherverts0 = [0, 1, 2, 3] otherverts0.remove(face0) otherverts0.remove(edge0) otherverts1 = [0, 1, 2, 3] otherverts1.remove(face1) otherverts1.remove(edge1) if (face0, edge0) in subtet_addresses[tet_index_0]: subtet0 = subtet_addresses[tet_index_0][(face0, edge0)] else: subtet0 = None if (face1, edge1) in subtet_addresses[tet_index_1]: subtet1 = subtet_addresses[tet_index_1][(face1, edge1)] else: subtet1 = None if subtet0 == None and subtet1 == None: pass ### both are fans, with no subtet, skip elif subtet0 != None and subtet1 != None: ### glue u, v = otherverts0 tet0perm = regina.Perm4(face0, edge0, edge0, face0, u, u, v, v) u, v = otherverts1 tet1perm = regina.Perm4(face1, edge1, edge1, face1, u, u, v, v) gluing = embed0.simplex().adjacentGluing(face0) subtet0.join(edge0, subtet1, tet1perm * gluing * tet0perm) ### perms act on left else: ### we have to walk around to find the right place to glue this toggle subtet, and remove the other unglued flag from the list if subtet1 == None: assert tet_types[tet_index_0] == 'toggle' toggle_tet_index = tet_index_0 toggle_face = face0 toggle_edge = edge0 subtet = subtet0 else: assert tet_types[tet_index_1] == 'toggle' toggle_tet_index = tet_index_1 toggle_face = face1 toggle_edge = edge1 subtet = subtet1 edge_verts = [0, 1, 2, 3] edge_verts.remove(toggle_edge) edge_verts.remove(toggle_face) toggle_e0, toggle_e1 = edge_verts e0, e1 = toggle_e0, toggle_e1 leading_vertex = toggle_edge trailing_vertex = toggle_face tet = tri.tetrahedron(toggle_tet_index) while True: gluing = tet.adjacentGluing(trailing_vertex) tet = tet.adjacentTetrahedron(trailing_vertex) e0, e1 = gluing[e0], gluing[e1] leading_vertex, trailing_vertex = gluing[ trailing_vertex], gluing[leading_vertex] if tet_types[tet.index()] == "toggle": break other_toggle_tet_index = tet.index() other_toggle_face = leading_vertex other_toggle_edge = trailing_vertex other_toggle_e0 = e0 other_toggle_e1 = e1 other_subtet = subtet_addresses[other_toggle_tet_index][( other_toggle_face, other_toggle_edge)] tetperm = regina.Perm4(toggle_face, toggle_edge, toggle_edge, toggle_face, toggle_e0, toggle_e0, toggle_e1, toggle_e1) other_tetperm = regina.Perm4(other_toggle_face, other_toggle_edge, other_toggle_edge, other_toggle_face, other_toggle_e0, other_toggle_e0, other_toggle_e1, other_toggle_e1) gluing = regina.Perm4(toggle_e0, other_toggle_e0, toggle_e1, other_toggle_e1, toggle_face, other_toggle_face, toggle_edge, other_toggle_edge) subtet.join(toggle_edge, other_subtet, other_tetperm * gluing * tetperm) return drilledTri, meridians
def drill(tri, loop, angle=None, branch=None, sig=None): # sig just for diagnostics """ Returns the new cusp formed by drilling """ if angle != None: face_coorientations = is_transverse_taut( tri, angle, return_type="face_coorientations") assert face_coorientations != False tet_vert_coorientations = is_transverse_taut( tri, angle, return_type="tet_vert_coorientations") assert tet_vert_coorientations != False original_tri = regina.Triangulation3(tri) original_countTetrahedra = tri.countTetrahedra() original_countBoundaryComponents = tri.countBoundaryComponents() ### add new tetrahedra new_0_tets = [] new_1_tets = [] ## both relative to regina's two embeddings for the face for i in range(len(loop)): new_0_tets.append(tri.newTetrahedron()) new_1_tets.append(tri.newTetrahedron()) ### we will glue tetrahedra together with a numbering that is convenient but ### unfortunately not oriented. We will orient later. # 1 pivot # /|\ # / | \ # / ,3. \ # /,' `.\ # 0---------2 leading # trailing for i in range(len(loop)): new_0_tets[i].join(1, new_1_tets[i], regina.Perm4(0, 1, 2, 3)) ### now glue along the loop path, need to worry about regina's embeddings for neighbouring triangles loop_face_tets0 = [] loop_face_vertices0 = [] loop_face_tets1 = [] loop_face_vertices1 = [ ] ### need to store these because they cannot be recomputed once we start ungluing faces for i in range(len(loop)): # print('collect info: i', i) face_data = loop[i] face_index = face_data[0] vert_nums = face_data[1] face = tri.triangles()[face_index] face_embed0 = face.embedding(0) face_tet = face_embed0.simplex() face_vertices = face_embed0.vertices() face_opposite_vert = face_vertices[3] face_other_non_edge_vert = face_vertices[ vert_nums[0]] ## opposite trailing vertex face_data_next = loop[(i + 1) % len(loop)] face_index_next = face_data_next[0] vert_nums_next = face_data_next[1] face_next = tri.triangles()[face_index_next] face_next_embed0 = face_next.embedding(0) face_next_tet = face_next_embed0.simplex() face_next_vertices = face_next_embed0.vertices() face_next_opposite_vert = face_next_vertices[3] face_next_other_non_edge_vert = face_next_vertices[ vert_nums_next[2]] ## opposite leading vertex ### things to store for later loop_face_tets0.append(face_tet) # store for later loop_face_vertices0.append(face_vertices) #store for later face_embed1 = face.embedding(1) loop_face_tets1.append(face_embed1.simplex()) loop_face_vertices1.append(face_embed1.vertices()) edge = face.edge(vert_nums[0]) ## opposite trailing vertex # print('edge index', edge.index()) assert edge == face_next.edge( vert_nums_next[2]) ## opposite leading vertex edgemapping = face.faceMapping(1, vert_nums[0]) next_edgemapping = face_next.faceMapping(1, vert_nums_next[2]) face_gluing_regina_numbering = next_edgemapping * ( edgemapping.inverse() ) ### maps vertices 0,1,2 on face to corresponding vertices on face_next assert face_gluing_regina_numbering[3] == 3 face_gluing_regina_numbering = regina.Perm3( face_gluing_regina_numbering[0], face_gluing_regina_numbering[1], face_gluing_regina_numbering[2]) assert face_gluing_regina_numbering[vert_nums[0]] == vert_nums_next[2] face_gluing = vert_nums_next.inverse( ) * face_gluing_regina_numbering * vert_nums assert face_gluing[0] == 2 signs = [] edge_embeddings = edge.embeddings() for embed in edge_embeddings: if embed.simplex() == face_tet: if set([embed.vertices()[2], embed.vertices()[3]]) == set( [face_opposite_vert, face_other_non_edge_vert]): # print('embed data face_tet', embed.simplex().index(), embed.vertices()) # print('embed edge vert nums', embed.vertices()[0], embed.vertices()[1]) signs.append(face_opposite_vert == embed.vertices()[2]) if embed.simplex() == face_next_tet: if set([embed.vertices()[2], embed.vertices()[3]]) == set([ face_next_opposite_vert, face_next_other_non_edge_vert ]): # print('embed data face_next_tet', embed.simplex().index(), embed.vertices()) # print('embed edge vert nums', embed.vertices()[0], embed.vertices()[1]) signs.append( face_next_opposite_vert == embed.vertices()[2]) # print('signs', signs) assert len(signs) == 2 if signs[0] == signs[ 1]: ### coorientations are same around the edge (not a transverse taut coorientation!) new_0_tets[i].join( 0, new_1_tets[(i + 1) % len(loop)], regina.Perm4(2, face_gluing[1], face_gluing[2], 3)) new_1_tets[i].join( 0, new_0_tets[(i + 1) % len(loop)], regina.Perm4(2, face_gluing[1], face_gluing[2], 3)) else: new_0_tets[i].join( 0, new_0_tets[(i + 1) % len(loop)], regina.Perm4(2, face_gluing[1], face_gluing[2], 3)) new_1_tets[i].join( 0, new_1_tets[(i + 1) % len(loop)], regina.Perm4(2, face_gluing[1], face_gluing[2], 3)) ### now unglue tri along the loop and glue in the new tetrahedra for i in range(len(loop)): # print('modify triangulation: i', i) vert_nums = loop[i][1] face_tet0 = loop_face_tets0[i] face_vertices0 = loop_face_vertices0[i] face_tet1 = loop_face_tets1[i] face_vertices1 = loop_face_vertices1[i] face_opposite_vert0 = face_vertices0[3] face_tet0.unjoin(face_opposite_vert0) ### glue torus shell to the old tetrahedra vert_nums_Perm4 = regina.Perm4(vert_nums[0], vert_nums[1], vert_nums[2], 3) new_0_tets[i].join(3, face_tet0, face_vertices0 * vert_nums_Perm4) new_1_tets[i].join(3, face_tet1, face_vertices1 * vert_nums_Perm4) assert tri.isValid() assert tri.countBoundaryComponents( ) == original_countBoundaryComponents + 1 if angle != None: for i in range(len(loop)): face_data = loop[i] face_index = face_data[0] face = original_tri.triangles()[face_index] vert_nums = face_data[1] face_embed0 = face.embedding(0) face_tet = face_embed0.simplex() face_vertices = face_embed0.vertices() face_opposite_vert = face_vertices[3] coor_points_out_of_tet0 = (tet_vert_coorientations[ face_tet.index()][face_opposite_vert] == +1) # if (flow_agrees_with_regina_numbers != face_cor_agrees_with_regina_numbers) != coor_points_out_of_tet0: if coor_points_out_of_tet0: angle.extend([0, 2]) else: angle.extend([2, 0]) # print(sig, loop, angle, is_taut(tri, angle)) assert is_taut(tri, angle) if branch != None: for i in range(len(loop)): branch.extend([1, 1]) assert is_branched(tri, branch) M = snappy.Manifold(tri) if M.volume() < 1.0: print('not hyperbolic', sig, loop, angle, M.volume()) assert False # print(M.verify_hyperbolicity()) ### very slow # print(M.volume()) # assert M.volume() > 1.0 ### ### now orient swaps = [regina.Perm4() ] * original_countTetrahedra ### identity permutations for i in range(len(loop)): if new_0_tets[i].adjacentGluing(3).sign() == 1: if angle != None: this_tet_angle = angle[original_countTetrahedra + 2 * i] else: this_tet_angle = 0 ### pi_location = 0 is an arbitrary choice swaps.append( reverse_tet_orientation(tri, new_0_tets[i], this_tet_angle)) else: swaps.append(regina.Perm4()) if new_1_tets[i].adjacentGluing(3).sign() == 1: if angle != None: this_tet_angle = angle[original_countTetrahedra + 2 * i + 1] else: this_tet_angle = 0 ### pi_location = 0 is an arbitrary choice swaps.append( reverse_tet_orientation(tri, new_1_tets[i], this_tet_angle)) else: swaps.append(regina.Perm4()) assert tri.isOriented() if angle != None: assert is_taut(tri, angle) if branch != None: # print('loop, branch, swaps', loop, branch, swaps) apply_swaps_to_branched_surface(branch, swaps) # print('loop, branch, swaps', loop, branch, swaps) assert is_branched(tri, branch) assert has_non_sing_semiflow(tri, branch) ### return the vertex of the triangulation corresponding to the drilled cusp drilled_cusp = new_0_tets[0].vertex(swaps[new_0_tets[0].index()][3]) assert drilled_cusp.degree() == len(new_0_tets) + len(new_1_tets) return drilled_cusp.index()
# All gems should have the same first permutation (third colour) # Example: all (1^1,3^k)-type 3-crystallisation for n=7 n = 7 gems = surv.family_three_crystallisations(7, sphere1=[[1], [0, 4, 2], [3, 5, 6]]) idn = list(range(n)) mu = surv.mu_online(n) sigmas = surv.cycle_to_oneline(gems[0][0], n) taus = [surv.cycle_to_oneline(g[1]) for g in gems] triangulations = [] for tau in taus: tau = [] perms = [idn, mu, sigma, tau] T = regina.Triangulation3() simplices = [T.newTetrahedron() for i in range(2 * n)] id4 = regina.Perm4() for c in range(4): for i in range(n): simplices[i].join(c, simplices[perms[c][i] + n], id4) triangulations.append(T) # Example: computing each unique isomorphism signature for triangulations unique_sigs = [] for T in triangulations: s = T.isoSig() if s not in unique_sigs: unique_sigs.append(s)
def excise_fans(tri, angle, fan_nums=None): vt = veering_triangulation(tri, angle) veering_colours = vt.veering_colours ## "red" or "blue" tet_types = vt.tet_types ### "toggle", "red" or "blue" tet_vert_coors = vt.coorientations if fan_nums == None: ## do all fans fan_nums = [ n for n in range(len(tet_types)) if tet_types[n] != "toggle" ] excisedAngle = angle[:] for fan_num in sorted(fan_nums, reverse=True): del excisedAngle[fan_num] minority_edge_pairs = [] for fan_num in fan_nums: assert tet_types[fan_num] != "toggle" tops, bottoms = get_top_and_bottom_nums(tet_vert_coors, fan_num) if 0 in tops: pi_pair = list(tops) else: pi_pair = list(bottoms) other = pi_pair[(pi_pair.index(0) + 1) % 2] for i in range(1, 4): if i != other: if vt.get_edge_between_verts_colour( fan_num, (0, i)) != tet_types[fan_num]: ### "red" or "blue" last = 6 - i - other ## the fourth vertex minority_edge_pairs.append([(0, i), (other, last)]) break excisedTri = regina.Triangulation3(tri) ### copy fan_tets = [excisedTri.tetrahedron(fan_num) for fan_num in fan_nums] for k, tet in enumerate(fan_tets): # print 'k', k, 'tet.index', tet.index() minority_edge_pair = minority_edge_pairs[k] # print minority_edge_pair ### record gluings for neighbours neighbours = [tet.adjacentSimplex(i) for i in range(4)] gluings = [tet.adjacentGluing(i) for i in range(4)] # print [neighbour.index() for neighbour in neighbours] # print gluings tet.isolate() ## now glue neighbours to each other if tet not in neighbours: to_glue = [0, 1, 2, 3] while to_glue != []: i = to_glue.pop() if i in minority_edge_pair[0]: j = minority_edge_pair[0][(minority_edge_pair[0].index(i) + 1) % 2] else: j = minority_edge_pair[1][(minority_edge_pair[1].index(i) + 1) % 2] teti = neighbours[i] tetj = neighbours[j] teti.join( gluings[i][i], tetj, gluings[j] * regina.Perm4(j, i) * (gluings[i].inverse())) to_glue.remove(j) # print i,j else: ### tet is glued to itself, which makes it trickier to remove ### first, find self-gluings self_gluings = [] self_gluings = [neighbours.index(tet)] self_gluings.append(neighbours.index(tet, self_gluings[0] + 1)) ### add second entry other_gluings = [0, 1, 2, 3] other_gluings.remove(self_gluings[0]) other_gluings.remove(self_gluings[1]) i, j = other_gluings teti = neighbours[i] tetj = neighbours[j] if i in minority_edge_pair[0]: p = minority_edge_pair[0][(minority_edge_pair[0].index(i) + 1) % 2] q = minority_edge_pair[1][(minority_edge_pair[1].index(j) + 1) % 2] else: p = minority_edge_pair[1][(minority_edge_pair[1].index(i) + 1) % 2] q = minority_edge_pair[0][(minority_edge_pair[0].index(j) + 1) % 2] teti.join( gluings[i][i], tetj, gluings[j] * regina.Perm4(j, q) * gluings[p] * regina.Perm4(p, i) * (gluings[i].inverse())) excisedTri.removeTetrahedron(tet) return excisedTri, excisedAngle
def twoThreeMove(tri, angle, face_num, perform = True, return_edge = False): """Apply a 2-3 move to a taut triangulation, if possible. If perform = False, returns if the move is possible. If perform = True, modifies tri, returns (tri, angle) for the performed move""" face = tri.triangle(face_num) embed0 = face.embedding(0) tet0 = embed0.simplex() tet_num0 = tet0.index() tet_0_face_num = embed0.face() vertices0 = embed0.vertices() # Maps vertices (0,1,2) of face to the corresponding vertex numbers of tet0 embed1 = face.embedding(1) tet1 = embed1.simplex() tet_num1 = tet1.index() tet_1_face_num = embed1.face() vertices1 = embed1.vertices() # Maps vertices (0,1,2) of face to the corresponding vertex numbers of tet1 if tet0 == tet1: ### Cannot perform a 2-3 move across a self-gluing return False ### taut 2-3 move is valid if the pis are on different edges of face ### this never happens if we start with a veering triangulation. ### for veering, the two-tetrahedron ball is always a continent. for i in range(3): j = (i+1) % 3 k = (i+2) % 3 if angle[tet_num0] == unsorted_vert_pair_to_edge_pair[(vertices0[j], vertices0[k])]: pi_num_0 = i if angle[tet_num1] == unsorted_vert_pair_to_edge_pair[(vertices1[j], vertices1[k])]: pi_num_1 = i if pi_num_0 == pi_num_1: return False if perform == False: return True ### check we do the same as regina... tri2 = regina.Triangulation3(tri) ## make a copy tri2.pachner(tri2.triangle(face_num)) ### We have to implement twoThreeMove ourselves. e.g. we do a 2-3 move to canonical fig 8 knot complement triangulation. ### All of the original tetrahedra are removed. I don't see any way to carry the angle structure through without knowing ### exactly how Ben's implementation works. ## record the tetrahedra and gluings adjacent to tet0 and tet1 tets = [tet0, tet1] vertices = [vertices0, vertices1] # print('2-3 vertices signs') # print([v.sign() for v in vertices]) gluings = [] for i in range(2): tet_gluings = [] for j in range(3): tet_gluings.append( [ tets[i].adjacentTetrahedron(vertices[i][j]), tets[i].adjacentGluing(vertices[i][j])] ) # if tets[i].adjacentTetrahedron(vertices[i][j]) in tets: # print('self gluing') gluings.append(tet_gluings) ### add new tetrahedra new_tets = [] for i in range(3): new_tets.append(tri.newTetrahedron()) ### glue around degree 3 edge for i in range(3): new_tets[i].join(2, new_tets[(i+1)%3], regina.Perm4(0,1,3,2)) ### replace mapping info with corresponding info for the 3 tet. Self gluings will be annoying... ### write verticesi[j] as vij ### tet0 new_tet0 ### _________ _________ ### ,'\ /`. ,'\`. ,'/`. ### ,' \ v03 / `. ,' \ `0' / `. ### ,' \ / `. ,' \ | / `. ### / \ \ / / \ /|\ \|/ /|\ ### /v02\ * /v01\ / | \ * / | \ ### / _\..... | ...../_ \ / | 3\..... | ...../2 | \ ### /_--"" / * \ ""--_\ /2 ,' / * \ `. 3\ ### \`.v12/ / \ \v11,'/ `. \`.| / /|\ \ |,'/ ### \ `./ / \ \,' / ----} \ `./ / | \ \,' / ### \ /`. / v00 \ ,'\ / ,' \|/`. / | \ ,'\|/ ### \ `. / \ ,' / \ `. / | \ ,' / ### \ `---------' / \ * 3 | 2 * / ### \ \ / / \ \ | / / ### \ \ v10 / / new_tet1 \ \ | / / new_tet2 ### \ \ / / \ \ | / / ### \ \ / / \ \|/ / ### \ * / \ * / ### tet1 \...|.../ \...|.../ ### \ | / \`.|.'/ ### \v13/ \ 1 / ### \|/ \|/ ### * * # permutations taking the vertices for a face of the 3-tet ball to the # vertices of the same face for the 2-tet ball # these should be even in order to preserve orientability. # exactly one of vertices[0] and vertices[1] is even, but it seems to depend on the face. # perms = [[regina.Perm4( vertices[0][3], vertices[0][0], vertices[0][1], vertices[0][2] ), ### opposite v00 # regina.Perm4( vertices[0][3], vertices[0][1], vertices[0][2], vertices[0][0] ), ### opposite v01 # regina.Perm4( vertices[0][3], vertices[0][2], vertices[0][0], vertices[0][1] ) ### opposite v02 # ], # [regina.Perm4( vertices[1][0], vertices[1][3], vertices[1][1], vertices[1][2] ), ### opposite v10 # regina.Perm4( vertices[1][1], vertices[1][3], vertices[1][2], vertices[1][0] ), ### opposite v11 # regina.Perm4( vertices[1][2], vertices[1][3], vertices[1][0], vertices[1][1] ) ### opposite v12 # ] # ] perms = [[vertices[0] * regina.Perm4( 3,0,1,2 ), ### opposite v00 vertices[0] * regina.Perm4( 3,1,2,0 ), ### opposite v01 vertices[0] * regina.Perm4( 3,2,0,1 ) ### opposite v02 ], [vertices[1] * regina.Perm4( 0,3,1,2 ), ### opposite v10 vertices[1] * regina.Perm4( 1,3,2,0 ), ### opposite v11 vertices[1] * regina.Perm4( 2,3,0,1 ) ### opposite v12 ] ] flip = perms[0][0].sign() == -1 if flip: #then all of the signs are wrong, switch 0 and 1 on input perms = [[p * regina.Perm4( 1,0,2,3 ) for p in a] for a in perms] # print('2-3 perms signs') # print([[p.sign() for p in a] for a in perms]) for i in range(2): for j in range(3): gluing = gluings[i][j] if gluing != None: if gluing[0] not in tets: ### not a self gluing gluing[1] = gluing[1] * perms[i][j] else: i_other = tets.index( gluing[0] ) otherfacenum = gluing[1][vertices[i][j]] j_other = [vertices[i_other][k] for k in range(4)].index(otherfacenum) assert gluings[i_other][j_other][0] == tets[i] assert gluings[i_other][j_other][1].inverse() == gluings[i][j][1] gluings[i_other][j_other] = None ### only do a self gluing from one side gluing[0] = new_tets[j_other] gluing[1] = perms[i_other][j_other].inverse() * gluing[1] * perms[i][j] ### unglue two tetrahedra tet0.isolate() tet1.isolate() ### remove the tetrahedra tri.removeSimplex(tet0) tri.removeSimplex(tet1) ### make the gluings on the boundary of the new ball for i in range(2): for j in range(3): if gluings[i][j] != None: if flip: new_tets[j].join(i, gluings[i][j][0], gluings[i][j][1]) else: new_tets[j].join(1 - i, gluings[i][j][0], gluings[i][j][1]) assert tri.isIsomorphicTo(tri2) assert tri.isOriented() ### update the angle structure tet_indices = [tet_num0, tet_num1] tet_indices.sort() angle.pop(tet_indices[1]) angle.pop(tet_indices[0]) ## remove from the list in the correct order! new_angle = [None, None, None] new_angle[pi_num_0] = 0 new_angle[pi_num_1] = 0 ### these two tetrahedra have their pi's on the new degree three edge third_index = 3 - (pi_num_0 + pi_num_1) if (pi_num_0 - third_index) % 3 == 1: new_angle[third_index] = 1 else: assert (pi_num_0 - third_index) % 3 == 2 new_angle[third_index] = 2 if flip: new_angle[third_index] = 3 - new_angle[third_index] angle.extend(new_angle) assert is_taut(tri, angle) if not return_edge: return [ tri, angle ] else: return [ tri, angle, new_tets[0].edge(0).index() ]
def threeTwoMove(tri, angle, edge_num, perform = True, return_triangle = False): """Apply a 3-2 move to a taut triangulation, if possible. If perform = False, returns if the move is possible. If perform = True, modifies tri, returns (tri, angle) for the performed move""" edge = tri.edge(edge_num) if edge.degree() != 3: return False tets = [] tet_nums = [] vertices = [] non_pi_tet_num = None for i in range(3): embed = edge.embedding(i) tets.append(embed.simplex()) tet_nums.append(tets[i].index()) vertices.append(embed.vertices()) if not there_is_a_pi_here(angle, embed): assert non_pi_tet_num == None non_pi_tet_num = embed.simplex().index() local_non_pi_tet_num = i if len(set([tet.index() for tet in tets])) != 3: return False ### tetrahedra must be distinct if not perform: return True ### taut 3-2 move is always possible if the 3-2 move is. ### record the "slope" of the pis on the non_pi_tet. This is a boolean non_pi_tet_positive = unsorted_vert_pair_to_edge_pair[ ( vertices[local_non_pi_tet_num][0], vertices[local_non_pi_tet_num][2] ) ] is_positive_slope = (angle[non_pi_tet_num] == non_pi_tet_positive) ### check we do the same as regina... tri2 = regina.Triangulation3(tri) ## make a copy tri2.pachner(tri2.edge(edge_num)) ## record the tetrahedra and gluings adjacent to the tets gluings = [] for i in range(3): tet_gluings = [] for j in range(2): tet_gluings.append( [ tets[i].adjacentTetrahedron(vertices[i][j]), tets[i].adjacentGluing(vertices[i][j])] ) gluings.append(tet_gluings) for i in range(3): assert tets[i].adjacentTetrahedron(vertices[i][2]) == tets[(i+1)%3] ### The edge embeddings should be ordered this way... ### add new tetrahedra new_tets = [] for i in range(2): new_tets.append(tri.newTetrahedron()) ### glue across face new_tets[0].join(3, new_tets[1], regina.Perm4(0,2,1,3)) ### replace mapping info with corresponding info for the 2 tet. Self gluings will be annoying... ### write vertices[i][j] as vij ### tets[0] new_tet1 ### _________ _________ ### ,'\`.v00,'/`. ,'\ /`. ### ,' \ `.' / `. ,' \ 3 / `. ### ,' v10\ | /v20 `. ,' \ / `. ### /|\ \|/ /|\ / \ \ / / \ ### / | \ * / | \ / \ * / \ ### v12/ | \..... | ...../ | \v23 / 1 _\..... | ...../_ 2 \ ### / ,' / * \ `. \ /_--"" / * \ ""--_\ ### \`.| /v03 /|\ v02\ |,'/ `. \`. 2 / / \ \ 1 ,'/ ### \ `./ / | \ \,' / ----} \ `./ / \ \,' / ### \|/`. / | \ ,'\|/ ,' \ /`. / 0 \ ,'\ / ### \ `. / | \ ,' / \ `. / \ ,' / ### \ * v13|v22 * / \ `---------' / ### \ \ | / / \ \ / / ### \ \ | / / \ \ 0 / / ### \ \ | / / \ \ / / ### tets[1] \ \|/ / tets[2] \ \ / / ### \ * / \ * / new_tet0 ### \..v01../ \...|.../ ### \`.|.'/ \ | / ### v11\ | /v21 \ 3 / ### \|/ \|/ ### * * # permutations taking the vertices for a face of the 2-tet ball to the # vertices of the same face for the 3-tet ball # these should be even in order to preserve orientability. # perms = [[regina.Perm4( vertices[0][0], vertices[0][2], vertices[0][3], vertices[0][1] ), ### opposite v00 # regina.Perm4( vertices[0][1], vertices[0][3], vertices[0][2], vertices[0][0] ) ### opposite v01 # ], # [regina.Perm4( vertices[1][3], vertices[1][0], vertices[1][2], vertices[1][1] ), ### opposite v10 # regina.Perm4( vertices[1][3], vertices[1][2], vertices[1][1], vertices[1][0] ) ### opposite v11 # ], # [regina.Perm4( vertices[2][2], vertices[2][3], vertices[2][0], vertices[2][1] ), ### opposite v20 # regina.Perm4( vertices[2][2], vertices[2][1], vertices[2][3], vertices[2][0] ) ### opposite v21 # ] # ] perms = [[vertices[0] * regina.Perm4( 0, 2, 3, 1 ), ### opposite v00 vertices[0] * regina.Perm4( 1, 3, 2, 0 ) ### opposite v01 ], [vertices[1] * regina.Perm4( 3, 0, 2, 1 ), ### opposite v10 vertices[1] * regina.Perm4( 3, 2, 1, 0 ) ### opposite v11 ], [vertices[2] * regina.Perm4( 2, 3, 0, 1 ), ### opposite v20 vertices[2] * regina.Perm4( 2, 1, 3, 0 ) ### opposite v21 ] ] for i in range(3): for j in range(2): gluing = gluings[i][j] if gluing != None: if gluing[0] not in tets: ### not a self gluing gluing[1] = gluing[1] * perms[i][j] else: i_other = tets.index( gluing[0] ) otherfacenum = gluing[1][vertices[i][j]] j_other = [vertices[i_other][k] for k in range(4)].index(otherfacenum) assert gluings[i_other][j_other][0] == tets[i] assert gluings[i_other][j_other][1].inverse() == gluings[i][j][1] gluings[i_other][j_other] = None ### only do a self gluing from one side gluing[0] = new_tets[j_other] ### j refers to the vertex on the same 3 side gluing[1] = perms[i_other][j_other].inverse() * gluing[1] * perms[i][j] ### unglue three tetrahedra for tet in tets: tet.isolate() ### remove the tetrahedra for tet in tets: tri.removeSimplex(tet) ### make the gluings on the boundary of the new ball for i in range(3): for j in range(2): if gluings[i][j] != None: if j == 0 or i == 0: assert new_tets[j].adjacentTetrahedron(i) == None ## not glued assert gluings[i][j][0].adjacentTetrahedron(gluings[i][j][1][i]) == None new_tets[j].join(i, gluings[i][j][0], gluings[i][j][1]) else: assert new_tets[j].adjacentTetrahedron(3 - i) == None ## not glued assert gluings[i][j][0].adjacentTetrahedron(gluings[i][j][1][3 - i]) == None new_tets[j].join(3 - i, gluings[i][j][0], gluings[i][j][1]) ## swap 1 and 2 assert tri.isIsomorphicTo(tri2) assert tri.isOriented() # ### update the angle structure tet_nums.sort() angle.pop(tet_nums[2]) angle.pop(tet_nums[1]) angle.pop(tet_nums[0]) ## remove from the list in the correct order! if local_non_pi_tet_num == 0: if is_positive_slope: new_angle = [0, 0] else: new_angle = [1, 1] elif local_non_pi_tet_num == 1: if is_positive_slope: new_angle = [2, 1] else: new_angle = [0, 2] else: assert local_non_pi_tet_num == 2 if is_positive_slope: new_angle = [1, 2] else: new_angle = [2, 0] angle.extend(new_angle) assert is_taut(tri, angle) if not return_triangle: return (tri, angle) else: return (tri, angle, new_tets[0].triangle(3).index())
def threeTwoMove(tri, edge_num, angle = None, branch = None, perform = True, return_triangle = False, return_vertex_perm = False): """Apply a 3-2 move to a triangulation with a taut structure and/or branched surface, if possible. If perform = False, returns if the move is possible. modifies tri, returns (tri, angle, branch) for the performed move. If return_vertex_perm, tells you how the vertices of the old triangulation correspond to the vertices of the new. If return_edge_consequences, tells you what happened to the edges: if an edge e survived then edge_consequences[e.index()] gives you the new index, if not then it returns None.""" ### perform = True isn't yet implemented for branch ### note if branch != None and this function does not return False, then there is only one possible branch # if branch != None: # assert has_non_sing_semiflow(tri, branch) ### we are checking this on the output of pachner moves so we don't need to check it here edge = tri.edge(edge_num) if edge.degree() != 3: return False tets = [] tet_nums = [] vertices = [] if angle != None: non_pi_tet_num = None for i in range(3): embed = edge.embedding(i) tets.append(embed.simplex()) tet_nums.append(tets[i].index()) vertices.append(embed.vertices()) if angle != None: if not there_is_a_pi_here(angle, embed): assert non_pi_tet_num == None non_pi_tet_num = embed.simplex().index() local_non_pi_tet_num = i tet_nums.sort() if len(set([tet.index() for tet in tets])) != 3: return False ### tetrahedra must be distinct if branch == None and not perform: return True ### taut 3-2 move is always possible if the 3-2 move is. if angle != None: ### record the "slope" of the pis on the non_pi_tet. This is a boolean non_pi_tet_positive = unsorted_vert_pair_to_edge_pair[ ( vertices[local_non_pi_tet_num][0], vertices[local_non_pi_tet_num][2] ) ] is_positive_slope = (angle[non_pi_tet_num] == non_pi_tet_positive) ### check we do the same as regina... tri2 = regina.Triangulation3(tri) ## make a copy tri2.pachner(tri2.edge(edge_num)) if return_vertex_perm: vertex_representatives = [] for c in tri.vertices(): embed = c.embedding(0) vertex_representatives.append((embed.simplex(), embed.face())) ### pair (tet, vert_num_of_that_tet) ### for testing: vertex_degrees = [v.degree() for v in tri.vertices()] ## record the tetrahedra and gluings adjacent to the tets gluings = [] for i in range(3): tet_gluings = [] for j in range(2): tet_gluings.append( [ tets[i].adjacentTetrahedron(vertices[i][j]), tets[i].adjacentGluing(vertices[i][j])] ) gluings.append(tet_gluings) for i in range(3): assert tets[i].adjacentTetrahedron(vertices[i][2]) == tets[(i+1)%3] ### The edge embeddings should be ordered this way... if branch != None: large_edges = [] ### record large edge info for the outer faces for i in range(3): this_tet_large_edges = [] for j in range(2): this_tet_large_edges.append(large_edge_of_face( branch[tets[i].index()], vertices[i][j] )) large_edges.append(this_tet_large_edges) ### add new tetrahedra new_tets = [] for i in range(2): new_tets.append(tri.newTetrahedron()) ### glue across face new_tets[0].join(3, new_tets[1], regina.Perm4(0,2,1,3)) ### replace mapping info with corresponding info for the 2 tet. Self gluings will be annoying... ### write vertices[i][j] as vij ### tets[0] new_tet1 ### _________ _________ ### ,'\`.v00,'/`. ,'\ /`. ### ,' \ `.' / `. ,' \ 3 / `. ### ,' v10\ | /v20 `. ,' \ / `. ### /|\ \|/ /|\ / \ \ / / \ ### / | \ * / | \ / \ * / \ ### v12/ | \..... | ...../ | \v23 / 1 _\..... | ...../_ 2 \ ### / ,' / * \ `. \ /_--"" / * \ ""--_\ ### \`.| /v03 /|\ v02\ |,'/ `. \`. 2 / / \ \ 1 ,'/ ### \ `./ / | \ \,' / ----} \ `./ / \ \,' / ### \|/`. / | \ ,'\|/ ,' \ /`. / 0 \ ,'\ / ### \ `. / | \ ,' / \ `. / \ ,' / ### \ * v13|v22 * / \ `---------' / ### \ \ | / / \ \ / / ### \ \ | / / \ \ 0 / / ### \ \ | / / \ \ / / ### tets[1] \ \|/ / tets[2] \ \ / / ### \ * / \ * / new_tet0 ### \..v01../ \...|.../ ### \`.|.'/ \ | / ### v11\ | /v21 \ 3 / ### \|/ \|/ ### * * # permutations taking the vertices for a face of the 2-tet ball to the # vertices of the same face for the 3-tet ball # these should be even in order to preserve orientability. # perms = [[regina.Perm4( vertices[0][0], vertices[0][2], vertices[0][3], vertices[0][1] ), ### opposite v00 # regina.Perm4( vertices[0][1], vertices[0][3], vertices[0][2], vertices[0][0] ) ### opposite v01 # ], # [regina.Perm4( vertices[1][3], vertices[1][0], vertices[1][2], vertices[1][1] ), ### opposite v10 # regina.Perm4( vertices[1][3], vertices[1][2], vertices[1][1], vertices[1][0] ) ### opposite v11 # ], # [regina.Perm4( vertices[2][2], vertices[2][3], vertices[2][0], vertices[2][1] ), ### opposite v20 # regina.Perm4( vertices[2][2], vertices[2][1], vertices[2][3], vertices[2][0] ) ### opposite v21 # ] # ] perms = [[vertices[0] * regina.Perm4( 0, 2, 3, 1 ), ### opposite v00 vertices[0] * regina.Perm4( 1, 3, 2, 0 ) ### opposite v01 ], [vertices[1] * regina.Perm4( 3, 0, 2, 1 ), ### opposite v10 vertices[1] * regina.Perm4( 3, 2, 1, 0 ) ### opposite v11 ], [vertices[2] * regina.Perm4( 2, 3, 0, 1 ), ### opposite v20 vertices[2] * regina.Perm4( 2, 1, 3, 0 ) ### opposite v21 ] ] for i in range(3): for j in range(2): gluing = gluings[i][j] if gluing != None: if gluing[0] not in tets: ### not a self gluing gluing[1] = gluing[1] * perms[i][j] else: i_other = tets.index( gluing[0] ) otherfacenum = gluing[1][vertices[i][j]] j_other = [vertices[i_other][k] for k in range(4)].index(otherfacenum) assert gluings[i_other][j_other][0] == tets[i] assert gluings[i_other][j_other][1].inverse() == gluings[i][j][1] gluings[i_other][j_other] = None ### only do a self gluing from one side gluing[0] = new_tets[j_other] ### j refers to the vertex on the same 3 side gluing[1] = perms[i_other][j_other].inverse() * gluing[1] * perms[i][j] if return_vertex_perm: new_vertex_representatives = [] for (tet, vert_num) in vertex_representatives: if tet in tets: which_tet = tets.index(tet) vert_num = vertices[which_tet].inverse()[vert_num] if vert_num == 0: new_vertex_representatives.append((new_tets[1], 3)) elif vert_num == 1: new_vertex_representatives.append((new_tets[0], 3)) elif vert_num == 2: new_vertex_representatives.append((new_tets[0], (which_tet + 1) % 3 )) elif vert_num == 3: new_vertex_representatives.append((new_tets[0], (which_tet - 1) % 3 )) else: new_vertex_representatives.append((tet, vert_num)) ### not changed by the move # ### for testing: polar_cusp_indices = [ tets[0].vertex( vertices[0][0] ).index(), tets[0].vertex( vertices[0][1] ).index() ] ### unglue three tetrahedra for tet in tets: tet.isolate() ### remove the tetrahedra for tet in tets: tri.removeSimplex(tet) ### make the gluings on the boundary of the new ball for i in range(3): for j in range(2): if gluings[i][j] != None: if j == 0 or i == 0: assert new_tets[j].adjacentTetrahedron(i) == None ## not glued assert gluings[i][j][0].adjacentTetrahedron(gluings[i][j][1][i]) == None new_tets[j].join(i, gluings[i][j][0], gluings[i][j][1]) else: assert new_tets[j].adjacentTetrahedron(3 - i) == None ## not glued assert gluings[i][j][0].adjacentTetrahedron(gluings[i][j][1][3 - i]) == None new_tets[j].join(3 - i, gluings[i][j][0], gluings[i][j][1]) ## swap 1 and 2 assert tri.isIsomorphicTo(tri2) assert tri.isOriented() if angle != None: ### update the angle structure angle.pop(tet_nums[2]) angle.pop(tet_nums[1]) angle.pop(tet_nums[0]) ## remove from the list in the correct order! if local_non_pi_tet_num == 0: if is_positive_slope: new_angle = [0, 0] else: new_angle = [1, 1] elif local_non_pi_tet_num == 1: if is_positive_slope: new_angle = [2, 1] else: new_angle = [0, 2] else: assert local_non_pi_tet_num == 2 if is_positive_slope: new_angle = [1, 2] else: new_angle = [2, 0] angle.extend(new_angle) assert is_taut(tri, angle) if branch != None: ### update the branched surface branch.pop(tet_nums[2]) branch.pop(tet_nums[1]) branch.pop(tet_nums[0]) ## remove from the list in the correct order! ### for each of the two new tetrahedra, figure out what their outer face train tracks are large_edges_new = [] ### record large edge info for the outer faces for i in range(3): this_tet_large_edges_new = [] for j in range(2): new_large_edge = perms[i][j].inverse()[ large_edges[i][j] ] this_tet_large_edges_new.append( new_large_edge ) large_edges_new.append(this_tet_large_edges_new) large_edges_new_transposed = [list(i) for i in zip(*large_edges_new)] branch0 = determine_possible_branch_given_three_faces([0,1,2], large_edges_new_transposed[0]) branch1 = determine_possible_branch_given_three_faces([0,2,1], large_edges_new_transposed[1]) if branch0 == None or branch1 == None: return False large_edge_for_new_tet0 = large_edge_of_face( branch0, 3 ) large_edge_for_new_tet1 = large_edge_of_face( branch1, 3 ) if large_edge_for_new_tet0 == large_edge_for_new_tet1: if large_edge_for_new_tet0 != 0: return False else: if large_edge_for_new_tet0 + large_edge_for_new_tet1 != 3: ### one must be 1, one must be 2 return False branch.extend([branch0, branch1]) assert is_branched(tri, branch) if not has_non_sing_semiflow(tri, branch): return False if return_vertex_perm: vertex_permutation = [] for (tet, vert_num) in new_vertex_representatives: vertex_permutation.append(tet.vertex(vert_num).index()) ### note that Regina's permutations can have up to 16 entries, lets just use lists for this ### for testing: new_vertex_degrees = [v.degree() for v in tri.vertices()] new_vertex_degrees_pulled_back = [new_vertex_degrees[vertex_permutation[i]] for i in range(len(vertex_degrees))] #if new_vertex_degrees != new_vertex_degrees_pulled_back: # print(vertex_permutation) # if vertex_permutation != list(range(len(new_vertex_representatives))): # print('3-2 permuted vertices', vertex_permutation, new_vertex_degrees, new_vertex_degrees_pulled_back, vertex_degrees) for i in polar_cusp_indices: vertex_degrees[i] -= 2 assert vertex_degrees == new_vertex_degrees_pulled_back # print(new_vertex_degrees_pulled_back) output = [tri] if angle != None: output.append(angle) if branch != None: output.append(branch) if return_triangle: output.append(new_tets[0].triangle(3).index()) if return_vertex_perm: output.append(vertex_permutation) return output
def twoThreeMove(tri, face_num, angle = None, branch = None, perform = True, return_edge = False, return_vertex_perm = False, return_edge_consequences = False): """Apply a 2-3 move to a triangulation with a taut structure and/or branched surface, if possible. If perform = False, returns if the move is possible. If perform = True, modifies tri, returns (tri, angle, possible_branches) for the performed move If return_edge, tells you the index of the newly created edge in the triangulation. If return_vertex_perm, tells you how the vertices of the old triangulation correspond to the vertices of the new. If return_edge_consequences, tells you what happened to the edges: edge_consequences[e.index()] gives you the new index.""" ### possible_branches is a list # if branch != None: # assert has_non_sing_semiflow(tri, branch) ### we are checking this on the output of pachner moves so we don't need to check it here ## Joe Christy says [p764, Branched surfaces and attractors I: Dynamic Branched Surfaces] that if the branched surface carries the stable lamination of a pseudo-Anosov flow then it has a non singular semi flow ## We hope that we can move to a veering triangulation through such branched surfaces face = tri.triangle(face_num) embed0 = face.embedding(0) tet0 = embed0.simplex() tet_num0 = tet0.index() tet_0_face_num = embed0.face() vertices0 = embed0.vertices() # Maps vertices (0,1,2) of face to the corresponding vertex numbers of tet0 embed1 = face.embedding(1) tet1 = embed1.simplex() tet_num1 = tet1.index() tet_1_face_num = embed1.face() vertices1 = embed1.vertices() # Maps vertices (0,1,2) of face to the corresponding vertex numbers of tet1 if tet0 == tet1: ### Cannot perform a 2-3 move across a self-gluing return False if angle != None: ### taut 2-3 move is valid if the pis are on different edges of face ### this never happens if we start with a veering triangulation. ### for veering, the two-tetrahedron ball is always a continent. for i in range(3): j = (i+1) % 3 k = (i+2) % 3 if angle[tet_num0] == unsorted_vert_pair_to_edge_pair[(vertices0[j], vertices0[k])]: pi_num_0 = i if angle[tet_num1] == unsorted_vert_pair_to_edge_pair[(vertices1[j], vertices1[k])]: pi_num_1 = i if pi_num_0 == pi_num_1: return False if perform == False: return True ### are all moves valid for the branched surface? ### for now, lets assume yes ### check we do the same as regina... tri2 = regina.Triangulation3(tri) ## make a copy tri2.pachner(tri2.triangle(face_num)) if return_vertex_perm: vertex_representatives = [] for c in tri.vertices(): embed = c.embedding(0) vertex_representatives.append((embed.simplex(), embed.face())) ### pair (tet, vert_num_of_that_tet) ### for testing: vertex_degrees = [v.degree() for v in tri.vertices()] if return_edge_consequences: edge_representatives = [] for e in tri.edges(): embed = e.embedding(0) ### HERE ##edge_representatives.append((embed.simplex(), embed.face())) ### pair (tet, vert_num_of_that_tet) ### We have to implement twoThreeMove ourselves. e.g. we do a 2-3 move to canonical fig 8 knot complement triangulation. ### All of the original tetrahedra are removed. I don't see any way to carry the angle structure through without knowing ### exactly how Ben's implementation works. ## record the tetrahedra and gluings adjacent to tet0 and tet1 tets = [tet0, tet1] vertices = [vertices0, vertices1] gluings = [] for i in range(2): tet_gluings = [] for j in range(3): tet_gluings.append( [ tets[i].adjacentTetrahedron(vertices[i][j]), tets[i].adjacentGluing(vertices[i][j])] ) # if tets[i].adjacentTetrahedron(vertices[i][j]) in tets: # print('self gluing') gluings.append(tet_gluings) if branch != None: large_edges = [] ### record large edge info for the outer faces for i in range(2): this_tet_large_edges = [] for j in range(3): this_tet_large_edges.append(large_edge_of_face( branch[tets[i].index()], vertices[i][j] )) large_edges.append(this_tet_large_edges) ### add new tetrahedra new_tets = [] for i in range(3): new_tets.append(tri.newTetrahedron()) ### glue around degree 3 edge for i in range(3): new_tets[i].join(2, new_tets[(i+1)%3], regina.Perm4(0,1,3,2)) ### replace mapping info with corresponding info for the 3 tet. Self gluings will be annoying... ### write verticesi[j] as vij ### tet0 new_tets[0] ### _________ _________ ### ,'\ /`. ,'\`. ,'/`. ### ,' \ v03 / `. ,' \ `0' / `. ### ,' \ / `. ,' \ | / `. ### / \ \ / / \ /|\ \|/ /|\ ### /v02\ * /v01\ / | \ * / | \ ### / _\..... | ...../_ \ / | 3\..... | ...../2 | \ ### /_--"" / * \ ""--_\ /2 ,' / * \ `. 3\ ### \`.v12/ / \ \v11,'/ `. \`.| / /|\ \ |,'/ ### \ `./ / \ \,' / ----} \ `./ / | \ \,' / ### \ /`. / v00 \ ,'\ / ,' \|/`. / | \ ,'\|/ ### \ `. / \ ,' / \ `. / | \ ,' / ### \ `---------' / \ * 3 | 2 * / ### \ \ / / \ \ | / / ### \ \ v10 / / new_tets[1] \ \ | / / new_tets[2] ### \ \ / / \ \ | / / ### \ \ / / \ \|/ / ### \ * / \ * / ### tet1 \...|.../ \...|.../ ### \ | / \`.|.'/ ### \v13/ \ 1 / ### \|/ \|/ ### * * # permutations taking the vertices for a face of the 3-tet ball to the # vertices of the same face for the 2-tet ball # these should be even in order to preserve orientability. # exactly one of vertices[0] and vertices[1] is even, but it seems to depend on the face. perms = [[vertices[0] * regina.Perm4( 3,0,1,2 ), ### opposite v00 vertices[0] * regina.Perm4( 3,1,2,0 ), ### opposite v01 vertices[0] * regina.Perm4( 3,2,0,1 ) ### opposite v02 ], [vertices[1] * regina.Perm4( 0,3,1,2 ), ### opposite v10 vertices[1] * regina.Perm4( 1,3,2,0 ), ### opposite v11 vertices[1] * regina.Perm4( 2,3,0,1 ) ### opposite v12 ] ] flip = perms[0][0].sign() == -1 if flip: #then all of the signs are wrong, switch 0 and 1 on input perms = [[p * regina.Perm4( 1,0,2,3 ) for p in a] for a in perms] for i in range(2): for j in range(3): gluing = gluings[i][j] if gluing != None: if gluing[0] not in tets: ### not a self gluing gluing[1] = gluing[1] * perms[i][j] else: i_other = tets.index( gluing[0] ) otherfacenum = gluing[1][vertices[i][j]] j_other = [vertices[i_other][k] for k in range(4)].index(otherfacenum) assert gluings[i_other][j_other][0] == tets[i] assert gluings[i_other][j_other][1].inverse() == gluings[i][j][1] gluings[i_other][j_other] = None ### only do a self gluing from one side gluing[0] = new_tets[j_other] gluing[1] = perms[i_other][j_other].inverse() * gluing[1] * perms[i][j] if return_vertex_perm: new_vertex_representatives = [] for (tet, vert_num) in vertex_representatives: if tet == tet0: triangle_vert_num = vertices[0].inverse()[vert_num] if triangle_vert_num == 3: if flip: new_vertex_representatives.append((new_tets[0], 1)) else: new_vertex_representatives.append((new_tets[0], 0)) else: new_vertex_representatives.append((new_tets[(triangle_vert_num + 1) % 3], 3)) elif tet == tet1: triangle_vert_num = vertices[1].inverse()[vert_num] if triangle_vert_num == 3: if flip: new_vertex_representatives.append((new_tets[0], 0)) else: new_vertex_representatives.append((new_tets[0], 1)) else: new_vertex_representatives.append((new_tets[(triangle_vert_num + 1) % 3], 3)) else: new_vertex_representatives.append((tet, vert_num)) ### not changed by the move ### for testing: polar_cusp_indices = [ tet0.vertex( vertices[0][3] ).index(), tet1.vertex( vertices[1][3] ).index() ] ### unglue two tetrahedra tet0.isolate() tet1.isolate() ### remove the tetrahedra tri.removeSimplex(tet0) tri.removeSimplex(tet1) ### make the gluings on the boundary of the new ball for i in range(2): for j in range(3): if gluings[i][j] != None: if flip: new_tets[j].join(i, gluings[i][j][0], gluings[i][j][1]) else: new_tets[j].join(1 - i, gluings[i][j][0], gluings[i][j][1]) assert tri.isIsomorphicTo(tri2) assert tri.isOriented() if angle != None: ### update the angle structure tet_indices = [tet_num0, tet_num1] tet_indices.sort() angle.pop(tet_indices[1]) angle.pop(tet_indices[0]) ## remove from the list in the correct order! new_angle = [None, None, None] new_angle[pi_num_0] = 0 new_angle[pi_num_1] = 0 ### these two tetrahedra have their pi's on the new degree three edge third_index = 3 - (pi_num_0 + pi_num_1) if (pi_num_0 - third_index) % 3 == 1: new_angle[third_index] = 1 else: assert (pi_num_0 - third_index) % 3 == 2 new_angle[third_index] = 2 if flip: new_angle[third_index] = 3 - new_angle[third_index] angle.extend(new_angle) assert is_taut(tri, angle) if branch != None: ### update the branched surface ### for each of the three new tetrahedra, figure out what their outer face train tracks are large_edges_new = [] ### record large edge info for the outer faces for i in range(2): this_tet_large_edges_new = [] for j in range(3): new_large_edge = perms[i][j].inverse()[ large_edges[i][j] ] if flip: assert new_large_edge != i ### the face number cannot be the large vertex for that face else: assert new_large_edge != 1 - i this_tet_large_edges_new.append( new_large_edge ) large_edges_new.append(this_tet_large_edges_new) candidate_branches = [] for j in range(3): if flip: candidate_branches.append( determine_possible_branch_given_two_faces((0,1), (large_edges_new[0][j], large_edges_new[1][j]) ) ) else: candidate_branches.append( determine_possible_branch_given_two_faces((1,0), (large_edges_new[0][j], large_edges_new[1][j]) ) ) ### update the branch structure, many possible ways tet_indices = [tet_num0, tet_num1] tet_indices.sort() branch.pop(tet_indices[1]) branch.pop(tet_indices[0]) ## remove from the list in the correct order! out_branches = [] for cand0 in candidate_branches[0]: for cand1 in candidate_branches[1]: for cand2 in candidate_branches[2]: candidate = branch[:] + [cand0, cand1, cand2] # print('candidate', candidate) # if is_branched(tri, candidate): if has_non_sing_semiflow(tri, candidate): out_branches.append(candidate) # assert len(out) > 0 ### this works if we check is_branched three lines above, but not if we check has_non_sing_semiflow if len(out_branches) == 0: ### with has_non_sing_semiflow instead, we might not get any return False if return_vertex_perm: vertex_permutation = [] for (tet, vert_num) in new_vertex_representatives: vertex_permutation.append(tet.vertex(vert_num).index()) ### note that Regina's permutations can have up to 16 entries, lets just use lists for this ### for testing: new_vertex_degrees = [v.degree() for v in tri.vertices()] new_vertex_degrees_pulled_back = [new_vertex_degrees[vertex_permutation[i]] for i in range(len(vertex_degrees))] # print(vertex_permutation) # if vertex_permutation != list(range(len(new_vertex_representatives))): # print('2-3 permuted vertices', vertex_permutation, new_vertex_degrees, new_vertex_degrees_pulled_back, vertex_degrees) for i in polar_cusp_indices: vertex_degrees[i] += 2 assert vertex_degrees == new_vertex_degrees_pulled_back # print(new_vertex_degrees_pulled_back) output = [tri] if angle != None: output.append(angle) if branch != None: output.append(out_branches) if return_edge: output.append(new_tets[0].edge(0).index()) if return_vertex_perm: output.append(vertex_permutation) return output
def __init__(self, manifold, qtons=None, quiet=False, tracker=False, allows_non_admissible=False, force_simplicial_homology=False): self._triangulation = None if isinstance(manifold, str): self._manifold = snappy.Manifold(manifold) elif isinstance(manifold, regina.engine.SnapPeaTriangulation): self._manifold = snappy.Manifold(manifold.snapPea()) self._triangulation = manifold elif isinstance(manifold, regina.engine.Triangulation3): self._manifold = snappy.Manifold(manifold.snapPea()) self._triangulation = manifold elif isinstance(manifold, snappy.Manifold): self._manifold = manifold elif isinstance(manifold, snappy.Triangulation): self._manifold = manifold for c in self._manifold.cusp_info(): if c.is_complete == False: self._manifold = self._manifold.filled_triangulation() break self._QUIET = quiet self._force_simplicial_homology = force_simplicial_homology self._num_cusps = self._manifold.num_cusps() if self._num_cusps != 0: try: L = self._manifold.link() self._knows_link_complement = True except ValueError: self._knows_link_complement = False #if self._knows_link_complement and bdy_H1_basis == 'natural': # self._bdy_H1_basis = 'natural' #else: # if self._manifold.verify_hyperbolicity()[0]: # self._manifold.set_peripheral_curves('shortest') # self._bdy_H1_basis = 'shortest' self._triangulation = regina.SnapPeaTriangulation( self._manifold._to_string()) self._angle_structure = solve_lin_gluing_eq(self._triangulation) self._peripheral_curve_mats = peripheral_curve_mats( self._manifold, self._triangulation) self._manifold_is_closed = False # check to make sure peripheral basis curves actually give a basis check, message = periph_basis_intersections(self) assert check, message # check to make sure each peripheral basis curve is connected (extra trivial loops # will mess up Euler char calculations). check, message = periph_basis_connected(self) assert check, message else: if self._triangulation == None: self._triangulation = regina.Triangulation3( self._manifold._to_string()) for _ in range(10): self._triangulation.intelligentSimplify() self._manifold_is_closed = True #self._bdy_H1_basis = None if not self._triangulation.isOriented(): self._triangulation.orient() self._qtons = qtons self._tkr = False self._allows_non_admissible = allows_non_admissible self._is_fibered = 'unknown' self._betti_number = self._triangulation.homologyH1().rank() # qtons memoization caches----- self._euler_char = {} self._map_to_ball = {} self._map_to_H2 = {} self._num_boundary_comps = {} self._over_facet = {} self._is_norm_minimizing = {} self._is_admissible = {} self._qtons_image_in_C2 = {} self._num_H1bdy_comps = {} self._has_mixed_bdy = {} self._is_embedded = {} self._ends_embedded = {} self._oriented_quads_mat = {} if self._manifold.num_cusps() > 0: self._boundary_slopes = {} self._spinning_slopes = {} self._map_to_H1bdy = {} if not self._QUIET: print( 'Enumerating quad transversely oriented normal surfaces (qtons)... ', end='') try: sys.stdout.flush() except AttributeError: pass if tracker: self._tkr = regina.ProgressTracker() # compute transversely oriented normal surfaces self._qtons = self.qtons() # name the surfaces by their index in the NormalSurfaces list for i in range(self._qtons.size()): self._qtons.surface(i).setName(str(i)) if not self._QUIET: print('Done.') try: sys.stdout.flush() except AttributeError: pass if self._betti_number > self._num_cusps: self._has_internal_homology = True else: self._has_internal_homology = False # if the manifold has internal homology or force_simplicial_homology==True then we need to use simplicial homology. if self._has_internal_homology or self._force_simplicial_homology: self._uses_simplicial_homology = True if not self._QUIET: print('computing simplicial homology...', end='') try: sys.stdout.flush() except AttributeError: pass self._face_map_to_C2 = get_face_map_to_C2(self._triangulation) self._quad_map_to_C2 = get_quad_map_to_C2(self._triangulation, self._face_map_to_C2) H2_basis_in_C2, P, qtons_image = H2_as_subspace_of_C2( self, self._face_map_to_C2, self._quad_map_to_C2) self._project_to_im_del3 = P self._qtons_image_in_C2 = { i: qtons_image[i] for i in range(len(qtons_image)) } assert len( H2_basis_in_C2) == self._betti_number, self._manifold.name( ) + ', force_simplicial_homology={}'.format( self._force_simplicial_homology) # raise an error if the qtons do not generate H2. This should only happen for a knot in a # rational homology sphere, with force_simplicial_homology=True. I = Matrix.identity(self._betti_number) B = Matrix(H2_basis_in_C2).transpose() A = B.solve_left(I) self._map_H2_to_standard_basis = A if not self._QUIET: print('Done.') try: sys.stdout.flush() except AttributeError: pass else: self._uses_simplicial_homology = False
def veering_mobius_dehn_surgery(triangulation, angle_struct, face_num): tri = regina.Triangulation3(triangulation) # make a copy angle = list(angle_struct) # make a copy face = tri.triangle(face_num) assert face.isMobiusBand() # Note that dunce caps cannot appear in a veering triangulation # Find which vertex is on both copies of the identified edge of the face edges = [face.edge(i) for i in range(3)] # edge i is opposite vertex i, i in [0, 1, 2] for j in range(3): if edges[j] == edges[(j + 1) % 3]: B = (j + 2) % 3 break embed0 = face.embedding(0) embed1 = face.embedding(1) tet0 = embed0.tetrahedron() tet1 = embed1.tetrahedron() embed0_verts = embed0.vertices() embed1_verts = embed1.vertices() # In tet0: B gives "b". Let "c" be the edge sharing a # pi with "b". Let "d" be the vertex not meeting the given face. # Let "a" be the remaining vertex. b = embed0.vertices()[B] c = shares_pi_with(angle[tet0.index()], b) d = embed0.vertices()[3] # ... use the face index a = [i for i in [0, 1, 2, 3] if i not in [b, c, d]].pop() # ... whatever is left # similarly in tet1 - B gives "q". Let "r" be the edge sharing a # pi with "q". Let "s" be the vertex not meeting the given face. # Let "p" be the remaining vertex. q = embed1.vertices()[B] r = shares_pi_with(angle[tet1.index()], q) s = embed1.vertices()[3] # ... use the face index p = [i for i in [0, 1, 2, 3] if i not in [q, r, s]].pop() # ... whatever is left # get colour of mobius strip pair_a = [b, c] pair_a.sort() mob_edge_a = tet0.edge(vert_pair_to_edge_num[tuple(pair_a)]) pair_c = [a, b] pair_c.sort() mob_edge_c = tet0.edge(vert_pair_to_edge_num[tuple(pair_c)]) assert mob_edge_a == mob_edge_c veering_colours = is_veering(tri, angle, return_type="veering_colours") assert veering_colours != False # otherwise the triangulation is not veering mob_colour = veering_colours[mob_edge_a.index()] # Now actually do the surgery tet0.unjoin(d) # same as tet1.unjoin(s) tet_new = tri.newTetrahedron() if mob_colour == "red": tet_new.join(0, tet_new, regina.Perm4(3, 0, 1, 2)) tet_new.join(1, tet0, regina.Perm4(c, d, a, b)) tet_new.join(2, tet1, regina.Perm4(q, p, s, r)) else: tet_new.join(1, tet_new, regina.Perm4(1, 3, 0, 2)) tet_new.join(2, tet0, regina.Perm4(a, b, d, c)) tet_new.join(0, tet1, regina.Perm4(s, r, p, q)) angle.append(0) # this is the correct taut angle for our new tetrahedron assert is_taut(tri, angle) assert is_veering(tri, angle) return tri, angle, tet_new.triangle(3).index()
def norm_ball(self): """ Return the Thurston norm ball. """ if not self._QUIET: print('Computing Thurston norm unit ball... ', end='') try: sys.stdout.flush() except AttributeError: pass pts_dict, rays_dict = self._norm_ball_points ### If M is not hyperbolic then rays_dict should be non-empty, and the norm ball should be non-compact. ### The below attempts to compute the non-compact norm ball, but it may be wrong. This is because ### (it seems) some surfaces may not be realized as spun normal surfaces. if len(rays_dict) != 0: V = VectorSpace(RR, self.betti_number()) ray_span = V.span([V(r) for r in rays_dict]) keys = [p for p in pts_dict] for p in keys: if V(p) in ray_span: _ = pts_dict.pop(p) polyhedron = Polyhedron(vertices=Matrix(pts_dict.keys()), rays=Matrix(rays_dict.keys()), base_ring=QQ, backend='cdd') rays = tuple([(rays_dict[tuple(i * vector(v))], i * vector(v)) for v in polyhedron.lines_list() for i in [1, -1]]) Rays = [ Ray(i, rays[i][0], rays[i][1], self) for i in range(len(rays)) ] vertices = tuple([(pts_dict[tuple(v)], vector(v)) for v in polyhedron.vertices_list() if not vector(v).is_zero()]) Vertices = [ NBVertex(i, vertices[i][0], vertices[i][1], self) for i in range(len(vertices)) ] # projected_verts = {} # Vertices = [] # for i,v in vertices: # v = vector(v) # v_proj, coeffs = orthogonal_proj(v, polyhedron.lines_list()) # v_proj = tuple(v_proj) # boundary_slopes = [] # num_boundary_comps = 0 # euler_char = coeffs[0]*self.euler_char(pts_dict[tuple(v)]) # for j in range(self.manifold().num_cusps()): # slope = vector((0,0)) # slope += vector(self.boundary_slopes(i)[j])*coeffs[0] # for k in range(len(polyhedron().lines_list())): # slope += vector(self.boundary_slopes(rays_dict[tuple(polyhedron.lines_list()[k])])[j])*coeffs[k+1] # boundary_slopes.append(slope) # num_boundary_comps += gcd(slope[0],slope[1]) # if v_proj not in projected_verts: # projected_verts[v_proj] = (num_boundary_comps, euler_char, boundary_slopes) # polyhedron = Polyhedron(vertices=Matrix(projected_verts.keys()), rays=Matrix(rays_dict.keys()), base_ring=QQ, backend='cdd') # for i in range(len(polyhedron.vertices_list())): # v = tuple(polyhedron.vertices_list()[i]) # if v in pts_dict: # Vertices.append(NBVertex(i, pts_dict[v], vector(v), self)) # else: # Vertices.append(NBVertex(i, None, vector(v), self, (projected_verts[v][0], projected_verts[v][1], projected_verts[v][2]))) else: polyhedron = Polyhedron(vertices=Matrix(pts_dict.keys()), base_ring=QQ) vertices = tuple([(pts_dict[tuple(v)], vector(v)) for v in polyhedron.vertices_list()]) Vertices = [ NBVertex(i, vertices[i][0], vertices[i][1], self) for i in range(len(vertices)) ] Rays = [] ball = TNormBall(Vertices, Rays, polyhedron) if self.num_cusps() == 1 and self.betti_number() == 1: M = self.manifold().copy() (p, q) = self.manifold().homological_longitude() elem_divs = [ div for div in M.homology().elementary_divisors() if div != 0 ] M.dehn_fill((p, q)) filled_elem_divs = [ div for div in M.homology().elementary_divisors() if div != 0 ] b = 1 for div in elem_divs: b *= div for div in filled_elem_divs: b /= div A = self.manifold().alexander_polynomial() A_norm = QQ(A.degree() - 1) try: v = ball.vertices()[0] except IndexError: pass ### below needs to be fixed. Currently does not account for virtual fibers. if A_norm <= 0 or not A.is_monic(): self._is_fibered = False ball._confirmed = True elif len(ball.vertices()) == 0: self._is_fibered = True polyhedron = Polyhedron(vertices=[[A_norm], [-A_norm]], base_ring=QQ) Vertices = [ NBVertex(0, None, (-1 / A_norm, ), self, (b, -A_norm, { 'outward': [(0, 1)], 'inward': [(0, 0)] })), NBVertex(1, None, (1 / A_norm, ), self, (b, -A_norm, { 'outward': [(0, -1)], 'inward': [(0, 0)] })) ] ball = TNormBall(Vertices, Rays, polyhedron) ball._confirmed = True elif A_norm == abs(v.euler_char()): assert self.num_H1bdy_comps(v.qtons_index()) == b self._is_fibered = 'unknown' ball._confirmed = True elif A_norm < abs(v.euler_char()): #M = self.manifold().copy() #M.dehn_fill(M.homological_longitude()) Mf = M.filled_triangulation() T = regina.Triangulation3(Mf._to_string()) boo = T.intelligentSimplify() ns = regina.NormalSurfaces.enumerate(T, regina.NS_QUAD, regina.NS_VERTEX, regina.NS_ALG_DEFAULT) non_trivial = [ i for i in range(ns.size()) if ns.surface(i).isOrientable() ] if len(non_trivial) > 1: non_trivial = [ i for i in non_trivial if ns.surface(i).cutAlong().isConnected() ] if len(non_trivial) == 0: ## something is wrong! print( 'Warning: failed to confirm that norm ball is correct (error: len(non_trivial)==0, culprit:M={}.' .format(self.manifold().name())) ball._confirmed = False elif len(non_trivial) >= 1: genus = min([ (2 - regina_to_sage_int(ns.surface(i).eulerChar())) / 2 for i in non_trivial ]) if 2 * genus - 2 + b == abs(v.euler_char()): self._is_fibered = False ball._confirmed = True elif 2 * genus - 2 + b == A_norm: multiplier = 1 / QQ(abs(v.euler_char()) / A_norm) if self.uses_simplicial_homology() == True: simplicial_class = multiplier * self.simplicial_class( v.qtons_index()) else: simplicial_class = None self._is_fibered == True polyhedron = Polyhedron(vertices=[[A_norm], [-A_norm]], base_ring=QQ) Vertices = [ NBVertex(0, None, (-1 / A_norm, ), self, (b, -A_norm, { 'outward': [(0, 1)], 'inward': [(0, 0)] })), NBVertex(1, None, (1 / A_norm, ), self, (b, -A_norm, { 'outward': [(0, -1)], 'inward': [(0, 0)] })) ] ball = TNormBall(Vertices, Rays, polyhedron) ball._confirmed = True else: print( 'Warning: failed to confirm that norm ball is correct (error: 2g-1!=A_norm or abs(X(S)), culprit:M={}.' .format(self.manifold().name())) ball._confirmed = False else: # if we are here, then something is wrong, and the following will cause an error to be thrown. assert A_norm <= abs( v.euler_char()) # (this should never happen) if not self._QUIET: print('Done.') try: sys.stdout.flush() except AttributeError: pass return ball
def is_edge_orientable(tri, angle, return_type="boolean"): """ checks to see if this veering triangulation is edge orientable. If return type is "tri angle" it returns the edge orientable double cover with its angle structure. Note that this is disconnected if and only if the given triangulation is edge orientable """ # return type can be "boolean", "veering_tet_vert_nums", or "tri angle" n = tri.countTetrahedra() veering_colours = is_veering(tri, angle, return_type="veering_colours") assert veering_colours != False # so we are veering tet_vert_coorientations = is_transverse_taut( tri, angle, return_type="tet_vert_coorientations") ### assumption: the first n tetrahedra have upper edge oriented according to Regina, the last n have it against Regina ### build our own model vertex numbering for each tetrahedron as follows: ### the top edge e is oriented by regina numbering, and gets vert_nums 1 and 2 in our ordering ### an equatorial edge e' of the same colour as e shares a vertex v with it. ### e and e' both point away from v or towards it. If away then the other end of e' is 3, ### else, the other end is 0 veering_tet_vert_nums = [ ] ### will populate with regina's vert nums, but our order. ### that is, veering_tet_vert_nums[1] and [2] will be the regina vert nums for the ends of the top edge for i in range(n): tet = tri.tetrahedron(i) veering_vert_nums = [None, None, None, None] top_vert_pair = get_tet_top_vert_nums(tet_vert_coorientations, i) # print(i, top_vert_pair) if not regina_edge_orientation_agrees(tet, top_vert_pair): top_vert_pair.reverse() assert regina_edge_orientation_agrees(tet, top_vert_pair) veering_vert_nums[1] = top_vert_pair[0] veering_vert_nums[2] = top_vert_pair[1] top_edge_num = vert_pair_to_edge_num[tuple(top_vert_pair)] top_edge_col = veering_colours[tet.edge(top_edge_num).index()] bottom_vert_pair = list(set(range(4)) - set(top_vert_pair)) bv, bv2 = bottom_vert_pair ## choose arbitrarily, now find which edge from the top vertices has same colour as bv for j, tv in enumerate(top_vert_pair): edge_col = veering_colours[tet.edge( vert_pair_to_edge_num[(bv, tv)]).index()] if edge_col == top_edge_col: if j == 0: ### bv shares an edge of same colour as top with tail of top edge veering_vert_nums[3] = bv veering_vert_nums[0] = bv2 else: ### bv shares an edge of same colour as top with head of top edge veering_vert_nums[0] = bv veering_vert_nums[3] = bv2 veering_tet_vert_nums.append(veering_vert_nums) # print('veering_tet_vert_nums', veering_tet_vert_nums) if return_type == "veering_tet_vert_nums": return veering_tet_vert_nums ### Now, when we glue two tetrahedra together along a face, the first of the three vertices in the veering_vert_num order ### on that tet's face glues to the first of the three vertices on the other tet's face, or to the third. ### depending on this, we go to the other part of the double cover, or not cover_tri = regina.Triangulation3() ## starts empty for i in range(2 * n): cover_tri.newTetrahedron() tet_faces = [] for i in range(n): for j in range(4): tet_faces.append((i, j)) while len(tet_faces) > 0: i, j = tet_faces.pop() tet = tri.tetrahedron(i) adjtet, adjgluing = tet.adjacentTetrahedron(j), tet.adjacentGluing(j) iN, jN = adjtet.index(), adjgluing[j] tet_faces.remove((iN, jN)) cover_tets = [cover_tri.tetrahedron(i), cover_tri.tetrahedron(i + n)] cover_tetsN = [ cover_tri.tetrahedron(iN), cover_tri.tetrahedron(iN + n) ] ### find the veering indices for the verts in the gluing on this tet and on adjtet face_veering_nums = veering_tet_vert_nums[i][:] face_veering_nums.remove(j) a, b, c = face_veering_nums neighbour_face_veering_nums = veering_tet_vert_nums[iN][:] neighbour_face_veering_nums.remove(jN) aN, bN, cN = neighbour_face_veering_nums assert adjgluing[b] == bN ### middles should match if adjgluing[a] == aN: ### veering orderings agree across the gluing assert adjgluing[c] == cN for k in range(2): cover_tets[k].join(j, cover_tetsN[k], adjgluing) else: ### veering orderings disagree across the gluing assert adjgluing[a] == cN and adjgluing[c] == aN for k in range(2): cover_tets[k].join(j, cover_tetsN[(k + 1) % 2], adjgluing) assert not cover_tri.hasBoundaryFacets() assert is_veering(cover_tri, angle + angle) if return_type == "boolean": return not cover_tri.isConnected( ) ### not connected if the original veering triangulation is edge orientable else: assert return_type == "tri angle" return cover_tri, angle + angle
def run_tests(num_to_check=10, smaller_num_to_check = 10): import taut veering_isosigs = parse_data_file("Data/veering_census.txt") print("testing is_taut") for sig in random.sample(veering_isosigs, num_to_check): tri, angle = taut.isosig_to_tri_angle(sig) assert taut.is_taut(tri, angle), sig print("testing isosig round trip") for sig in random.sample(veering_isosigs, num_to_check): tri, angle = taut.isosig_to_tri_angle(sig) recovered_sig = taut.isosig_from_tri_angle(tri, angle) assert sig == recovered_sig, sig # we only test this round trip - the other round trip does not # make sense because tri->isosig is many to one. import transverse_taut print("testing is_transverse_taut") for sig in random.sample(veering_isosigs, num_to_check): tri, angle = taut.isosig_to_tri_angle(sig) assert transverse_taut.is_transverse_taut(tri, angle), sig non_transverse_taut_isosigs = parse_data_file("Data/veering_non_transverse_taut_examples.txt") print("testing not is_transverse_taut") for sig in non_transverse_taut_isosigs: tri, angle = taut.isosig_to_tri_angle(sig) assert not transverse_taut.is_transverse_taut(tri, angle), sig import veering print("testing is_veering") for sig in random.sample(veering_isosigs, num_to_check): tri, angle = taut.isosig_to_tri_angle(sig) assert veering.is_veering(tri, angle), sig # tri, angle = taut.isosig_to_tri_angle("cPcbbbdxm_10") # explore_mobius_surgery_graph(tri, angle, max_tetrahedra = 12) # # tests to see that it makes only veering triangulations as it goes import veering_dehn_surgery print("testing veering_dehn_surgery") for sig in random.sample(veering_isosigs, num_to_check): tri, angle = taut.isosig_to_tri_angle(sig) for face_num in veering_dehn_surgery.get_mobius_strip_indices(tri): (tri_s, angle_s, face_num_s) = veering_dehn_surgery.veering_mobius_dehn_surgery(tri, angle, face_num) assert veering.is_veering(tri_s, angle_s), sig import veering_fan_excision print("testing veering_fan_excision") m003, _ = taut.isosig_to_tri_angle('cPcbbbdxm_10') m004, _ = taut.isosig_to_tri_angle('cPcbbbiht_12') for sig in random.sample(veering_isosigs, num_to_check): tri, angle = taut.isosig_to_tri_angle(sig) tet_types = veering.is_veering(tri, angle, return_type = "tet_types") if tet_types.count("toggle") == 2: excised_tri, _ = veering_fan_excision.excise_fans(tri, angle) assert ( excised_tri.isIsomorphicTo(m003) != None or excised_tri.isIsomorphicTo(m004) != None ), sig import pachner print("testing pachner with taut structure") for sig in random.sample(veering_isosigs, num_to_check): tri, angle = taut.isosig_to_tri_angle(sig) face_num = random.randrange(tri.countTriangles()) result = pachner.twoThreeMove(tri, face_num, angle = angle, return_edge = True) if result != False: tri2, angle2, edge_num = result tri3, angle3 = pachner.threeTwoMove(tri2, edge_num, angle = angle2) assert taut.isosig_from_tri_angle(tri, angle) == taut.isosig_from_tri_angle(tri3, angle3), sig import branched_surface import regina print("testing branched_surface and pachner with branched surface") for sig in random.sample(veering_isosigs, num_to_check): tri, angle = taut.isosig_to_tri_angle(sig) tri_original = regina.Triangulation3(tri) #copy branch = branched_surface.upper_branched_surface(tri, angle, return_lower = random.choice([True, False])) ### test branch isosig round trip sig_with_branch = branched_surface.isosig_from_tri_angle_branch(tri, angle, branch) tri2, angle2, branch2 = branched_surface.isosig_to_tri_angle_branch(sig_with_branch) assert (branch == branch2) and (angle == angle2), sig branch_original = branch[:] #copy face_num = random.randrange(tri.countTriangles()) out = pachner.twoThreeMove(tri, face_num, branch = branch, return_edge = True) if out != False: tri, possible_branches, edge_num = out tri, branch = pachner.threeTwoMove(tri, edge_num, branch = possible_branches[0]) all_isoms = tri.findAllIsomorphisms(tri_original) all_branches = [branched_surface.apply_isom_to_branched_surface(branch, isom) for isom in all_isoms] assert branch_original in all_branches, sig import flow_cycles import drill print("testing taut and branched drill + semiflows on drillings") for sig in random.sample(veering_isosigs, smaller_num_to_check): tri, angle = taut.isosig_to_tri_angle(sig) branch = branched_surface.upper_branched_surface(tri, angle) ### also checks for veering and transverse taut found_loops = flow_cycles.find_flow_cycles(tri, branch) for loop in random.sample(found_loops, min(len(found_loops), 5)): ## drill along at most 5 loops tri, angle = taut.isosig_to_tri_angle(sig) branch = branched_surface.upper_branched_surface(tri, angle) tri_loop = flow_cycles.flow_cycle_to_triangle_loop(tri, branch, loop) if tri_loop != False: if not flow_cycles.tri_loop_is_boundary_parallel(tri_loop, tri): drill.drill(tri, tri_loop, angle = angle, branch = branch, sig = sig) assert branched_surface.has_non_sing_semiflow(tri, branch), sig print("all basic tests passed") try: import snappy import snappy_util snappy_working = True except: print("failed to import from snappy?") snappy_working = False if snappy_working: print("testing algebraic intersection") census = snappy.OrientableCuspedCensus() # not a set or list, so can't use random.sample for i in range(10): M = random.choice(census) n = M.num_cusps() peripheral_curves = M.gluing_equations()[-2*n:] for i in range(2*n): for j in range(i, 2*n): alg_int = snappy_util.algebraic_intersection(peripheral_curves[i], peripheral_curves[j]) if i % 2 == 0 and j == i + 1: assert alg_int == 1, M.name() else: assert alg_int == 0, M.name() if snappy_working: import veering_drill_midsurface_bdy print("testing veering drilling and filling") for sig in random.sample(veering_isosigs[:3000], num_to_check): T, per = veering_drill_midsurface_bdy.drill_midsurface_bdy(sig) M = snappy.Manifold(T.snapPea()) M.set_peripheral_curves("shortest") L = snappy_util.get_slopes_from_peripherals(M, per) M.dehn_fill(L) N = snappy.Manifold(sig.split("_")[0]) assert M.is_isometric_to(N), sig if snappy_working: print("all tests depending on snappy passed") # try: # from hashlib import md5 # from os import remove # import pyx # from boundary_triangulation import draw_triangulation_boundary_from_veering_isosig # pyx_working = True # except: # print("failed to import from pyx?") # pyx_working = False # ladders_style_sigs = { # "cPcbbbiht_12": "f34c1fdf65db9d02994752814803ae01", # "gLLAQbecdfffhhnkqnc_120012": "091c85b4f4877276bfd8a955b769b496", # "kLALPPzkcbbegfhgijjhhrwaaxnxxn_1221100101": "a0f15a8454f715f492c74ce1073a13a4", # } # geometric_style_sigs = { # "cPcbbbiht_12": "1e74d0b68160c4922e85a5adb20a0f1d", # "gLLAQbecdfffhhnkqnc_120012": "856a1fce74eb64f519bcda083303bd8f", # "kLALPPzkcbbegfhgijjhhrwaaxnxxn_1221100101": "33bd23b34c5d977a103fa50ffe63120a", # } # args = { # "draw_boundary_triangulation":True, # "draw_triangles_near_poles": False, # "ct_depth":-1, # "ct_epsilon":0.03, # "global_drawing_scale": 4, # "delta": 0.2, # "ladder_width": 10.0, # "ladder_height": 20.0, # "draw_labels": True, # } # shapes_data = read_from_pickle("Data/veering_shapes_up_to_ten_tetrahedra.pkl") # if pyx_working: # for sig in ladders_style_sigs: # print("testing boundary triangulation pictures, ladder style", sig) # args["tet_shapes"] = shapes_data[sig] # args["style"] = "ladders" # file_name = draw_triangulation_boundary_from_veering_isosig(sig, args = args) # f = open(file_name, "rb") # file_hash = md5(f.read()) # assert file_hash.hexdigest() == ladders_style_sigs[sig] # f.close() # remove(file_name) # if pyx_working: # for sig in geometric_style_sigs: # print("testing boundary triangulation pictures, ladder style", sig) # args["tet_shapes"] = shapes_data[sig] # args["style"] = "geometric" # file_name = draw_triangulation_boundary_from_veering_isosig(sig, args = args) # f = open(file_name, "rb") # file_hash = md5(f.read()) # assert file_hash.hexdigest() == geometric_style_sigs[sig] # f.close() # remove(file_name) # if pyx_working: # print("all tests depending on pyx passed") veering_polys = { "cPcbbbiht_12": [-4, -1, 1, 4], "eLMkbcddddedde_2100": [-2, -2, -2, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 2, 2], "gLLAQbecdfffhhnkqnc_120012": [-1, -1, -1, -1, 1, 1, 1, 1], "gLLPQcdfefefuoaaauo_022110": [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1], } # veering_polys = { ### old # "cPcbbbiht_12": "a^3 - 4*a^2 + 4*a - 1", # "eLMkbcddddedde_2100": "a^6*b - a^6 - 2*a^5*b - a^4*b^2 + a^5 + 2*a^4*b + a^3*b^2 - 2*a^3*b + a^3 + 2*a^2*b + a*b^2 - a^2 - 2*a*b - b^2 + b", # "gLLAQbecdfffhhnkqnc_120012": "a^7 + a^6 + a^5 + a^4 - a^3 - a^2 - a - 1", # "gLLPQcdfefefuoaaauo_022110": "a^12*b^3 - a^11*b^2 - a^10*b^3 - a^10*b^2 - a^7*b^3 - a^7*b^2 - a^6*b^3 + a^7*b + a^5*b^2 - a^6 - a^5*b - a^5 - a^2*b - a^2 - a*b + 1", # } taut_polys = { "cPcbbbiht_12": [-3, 1, 1], "eLMkbcddddedde_2100": [-1, -1, -1, 1, 1], "iLLAwQcccedfghhhlnhcqeesr_12001122": [], } # taut_polys = { ### old # "cPcbbbiht_12": "a^2 - 3*a + 1", # "eLMkbcddddedde_2100": "a^2*b - a^2 - a*b - b^2 + b", # "iLLAwQcccedfghhhlnhcqeesr_12001122": "0", # } torus_bundles = [ "cPcbbbiht_12", "eLMkbcdddhhqqa_1220", "gLMzQbcdefffhhqqqdl_122002", ] measured = [ "gLLAQbecdfffhhnkqnc_120012", "iLLALQcccedhgghhlnxkxrkaa_12001112", "iLLAwQcccedfghhhlnhcqeesr_12001122", ] empties = [ "fLAMcaccdeejsnaxk_20010", "gLALQbcbeeffhhwsras_211220", "hLALAkbcbeefgghhwsraqj_2112202", ] try: from sage.rings.integer_ring import ZZ sage_working = True except: print("failed to import from sage?") sage_working = False if sage_working: import taut_polytope print("testing is_layered") for sig in veering_isosigs[:17]: assert taut_polytope.is_layered(sig), sig for sig in veering_isosigs[17:21]: assert not taut_polytope.is_layered(sig), sig if sage_working: import fibered print("testing is_fibered") mflds = parse_data_file("Data/mflds_which_fiber.txt") mflds = [line.split("\t")[0:2] for line in mflds] for (name, kind) in random.sample(mflds, num_to_check): assert fibered.is_fibered(name) == (kind == "fibered"), name if sage_working: import veering_polynomial import taut_polynomial print("testing veering poly") for sig in veering_polys: p = veering_polynomial.veering_polynomial(sig) assert check_polynomial_coefficients(p, veering_polys[sig]), sig ### Nov 2021: sage 9.4 changed how smith normal form works, which changed our polynomials ### to equivalent but not equal polynomials. To avoid this kind of change breaking things ### in the future, we changed to comparing the list of coefficients. # assert p.__repr__() == veering_polys[sig] print("testing taut poly") for sig in taut_polys: p = taut_polynomial.taut_polynomial_via_tree(sig) assert check_polynomial_coefficients(p, taut_polys[sig]), sig # assert p.__repr__() == taut_polys[sig] print("testing divide") for sig in random.sample(veering_isosigs[:3000], num_to_check): p = veering_polynomial.veering_polynomial(sig) q = taut_polynomial.taut_polynomial_via_tree(sig) if q == 0: assert p == 0, sig else: assert q.divides(p), sig if sage_working: print("testing alex") for sig in random.sample(veering_isosigs[:3000], num_to_check): snap_sig = sig.split("_")[0] M = snappy.Manifold(snap_sig) if M.homology().betti_number() == 1: assert taut_polynomial.taut_polynomial_via_tree(sig, mode = "alexander") == M.alexander_polynomial(), sig if sage_working: # would be nice to automate this - need to fetch the angle # structure say via z_charge.py... print("testing is_torus_bundle") for sig in torus_bundles: assert taut_polytope.is_torus_bundle(sig), sig if sage_working: # ditto print("testing is_layered") for sig in torus_bundles: assert taut_polytope.is_layered(sig), sig print("testing measured") for sig in measured: assert taut_polytope.LMN_tri_angle(sig) == "M", sig print("testing empty") for sig in empties: assert taut_polytope.LMN_tri_angle(sig) == "N", sig if sage_working: # warning - this takes random amounts of time! print("testing hom dim") for sig in random.sample(veering_isosigs[:3000], 3): # magic number # dimension = zero if and only if nothing is carried. assert (taut_polytope.taut_cone_homological_dim(sig) == 0) == (taut_polytope.LMN_tri_angle(sig) == "N"), sig if sage_working: boundary_cycles = { ("eLMkbcddddedde_2100",(2,5,5,1,3,4,7,1)): "((-7, -7, 0, 0, 4, -3, 7, 0), (7, 7, 0, 0, -4, 3, -7, 0))", ("iLLLQPcbeegefhhhhhhahahha_01110221",(0,1,0,0,0,1,0,0,0,0,0,0,1,0,1,0)): "((0, 0, -1, 1, 1, 0, 1, 1, -1, 0, 0, 0, 0, 1, 0, 1), (0, 0, 1, -1, -1, 0, -1, -1, 1, 0, 0, 0, 0, -1, 0, -1))", ("ivvPQQcfhghgfghfaaaaaaaaa_01122000",(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1)): "((1, 1, 2, 0, -1, 2, 1, -3, 0, -1, 0, -2, -1, 0, 3, -2), (1, 1, 0, 2, -1, 0, -3, 1, 2, -1, -2, 0, 3, -2, -1, 0), (-2, 0, -3, 1, 2, -1, 0, 2, -1, 0, 3, 1, -2, 1, 0, -1), (0, -2, 1, -3, 0, -1, 2, 0, -1, 2, -1, 1, 0, 1, -2, 3))", } taut_polys_with_cycles = { ("eLMkbcddddedde_2100", ((7, 7, 0, 0, -4, 3, -7, 0),)): [-1, -1, -1, 1, 1], ("iLLLQPcbeegefhhhhhhahahha_01110221", ((0, 0, 1, -1, -1, 0, -1, -1, 1, 0, 0, 0, 0, -1, 0, -1),)): [1, 1, 2], ("ivvPQQcfhghgfghfaaaaaaaaa_01122000", ((1, 1, 2, 0, -1, 2, 1, -3, 0, -1, 0, -2, -1, 0, 3, -2), (1, 1, 0, 2, -1, 0, -3, 1, 2, -1, -2, 0, 3, -2, -1, 0))): [-4, -1, -1, 1, 1], } # taut_polys_with_cycles = { # ("eLMkbcddddedde_2100", ((7, 7, 0, 0, -4, 3, -7, 0),)): "a^14 - a^8 - a^7 - a^6 + 1", # ("iLLLQPcbeegefhhhhhhahahha_01110221", ((0, 0, 1, -1, -1, 0, -1, -1, 1, 0, 0, 0, 0, -1, 0, -1),)): "a^2 + 2*a + 1", # ("ivvPQQcfhghgfghfaaaaaaaaa_01122000", ((1, 1, 2, 0, -1, 2, 1, -3, 0, -1, 0, -2, -1, 0, 3, -2), (1, 1, 0, 2, -1, 0, -3, 1, 2, -1, -2, 0, 3, -2, -1, 0))): "a*b^2 - a^2 - 4*a*b - b^2 + a", # } taut_polys_image = { ('eLMkbcddddedde_2100', ((7, 8, -1, 0, -4, 4, -8, 0),)):[-1, -1, -1, 1, 1], ('ivvPQQcfhghgfghfaaaaaaaaa_01122000', ((1, 1, 2, 0, -1, 2, 1, -3, 0, -1, 0, -2, -1, 0, 3, -2),)):[-2, -2, -1, -1, 1, 1], ('ivvPQQcfhghgfghfaaaaaaaaa_01122000', ((1, 1, 2, 0, -1, 2, 1, -3, 0, -1, 0, -2, -1, 0, 3, -2), (1, 1, 0, 2, -1, 0, -3, 1, 2, -1, -2, 0, 3, -2, -1, 0))):[-4, -1, -1, 1, 1] } # taut_polys_image = { # ('eLMkbcddddedde_2100', ((7, 8, -1, 0, -4, 4, -8, 0),)):"a^16 - a^9 - a^8 - a^7 + 1", # ('ivvPQQcfhghgfghfaaaaaaaaa_01122000', ((1, 1, 2, 0, -1, 2, 1, -3, 0, -1, 0, -2, -1, 0, 3, -2),)):"a*b^2*c - 2*a*b*c - b^2*c - a^2 - 2*a*b + a", # ('ivvPQQcfhghgfghfaaaaaaaaa_01122000', ((1, 1, 2, 0, -1, 2, 1, -3, 0, -1, 0, -2, -1, 0, 3, -2), (1, 1, 0, 2, -1, 0, -3, 1, 2, -1, -2, 0, 3, -2, -1, 0))):"a*b^2 - a^2 - 4*a*b - b^2 + a" # } alex_polys_with_cycles = { ("eLMkbcddddedde_2100",((7, 7, 0, 0, -4, 3, -7, 0),)): [-2, -1, -1, -1, 1, 1, 1, 2], ("iLLLQPcbeegefhhhhhhahahha_01110221", ((0, 0, 1, -1, -1, 0, -1, -1, 1, 0, 0, 0, 0, -1, 0, -1),)): [-3, -1, 1, 3], ("ivvPQQcfhghgfghfaaaaaaaaa_01122000", ((1, 1, 2, 0, -1, 2, 1, -3, 0, -1, 0, -2, -1, 0, 3, -2), (1, 1, 0, 2, -1, 0, -3, 1, 2, -1, -2, 0, 3, -2, -1, 0))): [-1, -1, 1, 1], } # alex_polys_with_cycles = { # ("eLMkbcddddedde_2100",((7, 7, 0, 0, -4, 3, -7, 0),)): "a^15 - a^14 + a^9 - 2*a^8 + 2*a^7 - a^6 + a - 1", # ("iLLLQPcbeegefhhhhhhahahha_01110221", ((0, 0, 1, -1, -1, 0, -1, -1, 1, 0, 0, 0, 0, -1, 0, -1),)): "3*a^3 - a^2 + a - 3", # ("ivvPQQcfhghgfghfaaaaaaaaa_01122000", ((1, 1, 2, 0, -1, 2, 1, -3, 0, -1, 0, -2, -1, 0, 3, -2), (1, 1, 0, 2, -1, 0, -3, 1, 2, -1, -2, 0, 3, -2, -1, 0))): "a*b^2 - a^2 - b^2 + a", # } if sage_working: import taut_carried print("testing boundary cycles") for sig, surface in boundary_cycles: surface_list = list(surface) cycles = taut_carried.boundary_cycles_from_surface(sig, surface_list) cycles = tuple(tuple(cycle) for cycle in cycles) assert cycles.__repr__() == boundary_cycles[(sig, surface)], sig if sage_working: print("testing taut with cycles") for sig, cycles in taut_polys_with_cycles: cycles_in = [list(cycle) for cycle in cycles] p = taut_polynomial.taut_polynomial_via_tree(sig, cycles_in) assert check_polynomial_coefficients(p, taut_polys_with_cycles[(sig, cycles)]), sig # assert p.__repr__() == taut_polys_with_cycles[(sig, cycles)] if sage_working: print("testing taut with images") for sig, cycles in taut_polys_image: cycles_in = [list(cycle) for cycle in cycles] p = taut_polynomial.taut_polynomial_image(sig, cycles_in) assert check_polynomial_coefficients(p, taut_polys_image[(sig, cycles)]), sig # assert p.__repr__() == taut_polys_image[(sig, cycles)] if sage_working: print("testing alex with cycles") for sig, cycles in alex_polys_with_cycles: cycles_in = [list(cycle) for cycle in cycles] p = taut_polynomial.taut_polynomial_via_tree(sig, cycles_in, mode = "alexander") assert check_polynomial_coefficients(p, alex_polys_with_cycles[(sig, cycles)]), sig # assert p.__repr__() == alex_polys_with_cycles[(sig, cycles)] if sage_working: import edge_orientability import taut_euler_class print("testing euler and edge orientability") for sig in random.sample(veering_isosigs[:3000], 3): # Theorem: If (tri, angle) is edge orientable then e = 0. assert not ( edge_orientability.is_edge_orientable(sig) and (taut_euler_class.order_of_euler_class_wrapper(sig) == 2) ), sig if sage_working: # Theorem: If (tri, angle) is edge orientable then taut poly = alex poly. # taut_polynomial.taut_polynomial_via_tree(sig, mode = "alexander") == # taut_polynomial.taut_polynomial_via_tree(sig, mode = "taut") pass if sage_working: print("testing exotics") for sig in random.sample(veering_isosigs[:3000], 3): tri, angle = taut.isosig_to_tri_angle(sig) T = veering.veering_triangulation(tri, angle) is_eo = T.is_edge_orientable() for angle in T.exotic_angles(): assert taut_polytope.taut_cone_homological_dim(tri, angle) == 0, sig assert is_eo == transverse_taut.is_transverse_taut(tri, angle), sig ### test for drill_midsurface_bdy: drill then fill, check you get the same manifold if sage_working: from sage.combinat.words.word_generators import words from sage.modules.free_module_integer import IntegerLattice from sage.modules.free_module import VectorSpace from sage.matrix.constructor import Matrix import z_charge import z2_taut import regina ZZ2 = ZZ.quotient(ZZ(2)) sig_starts = ["b+-LR", "b++LR"] print("testing lattice for punc torus bundle") for i in range(3): for sig_start in sig_starts: sig = sig_start + str(words.RandomWord(8, 2, "LR")) # 8 is a magic number M = snappy.Manifold(sig) tri = regina.Triangulation3(M) t, A = z_charge.sol_and_kernel(M) B = z_charge.leading_trailing_deformations(M) C = z2_taut.cohomology_loops(tri) AA = IntegerLattice(A) BB = IntegerLattice(B) assert AA == BB.saturation(), sig dim = 3*M.num_tetrahedra() V = VectorSpace(ZZ2, dim) AA = V.subspace(A) BB = V.subspace(B) CM = Matrix(ZZ2, C) CC = CM.right_kernel() assert AA.intersection(CC) == BB , sig ## so l-t defms are the part of the kernel that doesn't flip over if sage_working: print("testing charges for punc torus bundle") for i in range(3): for sig_start in sig_starts: sig = sig_start + str(words.RandomWord(8, 2, "LR")) # 8 is a magic number M = snappy.Manifold(sig) assert z_charge.can_deal_with_reduced_angles(M), sig if sage_working: import carried_surface import mutation print("testing building carried surfaces and mutations") sigs_weights = [ ['iLLLPQccdgefhhghqrqqssvof_02221000', (0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0)], ['jLLAvQQcedehihiihiinasmkutn_011220000', (2, 0, 1, 0, 0, 0, 1, 2, 0, 2, 0, 2, 1, 0, 0, 0, 1, 0)], ['jLLAvQQcedehihiihiinasmkutn_011220000', (0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0)], ['jLLLMPQcdgfhfhiiihshassspiq_122201101', (0, 0, 4, 0, 4, 1, 0, 2, 2, 0, 1, 0, 0, 4, 0, 4, 0, 0)] ] strata = [ ((1, 2), [2, 2]), ((2, 4), [5, 5, 1, 1]), ((0, 3), [2, 0, 0]), ((6, 1), [22]) ] orders_of_veering_symmetry_groups = [4, 2, 2, 2] for i in range(len(sigs_weights)): tri, angle = taut.isosig_to_tri_angle(sigs_weights[i][0]) weights = sigs_weights[i][1] surface, edge_colours = carried_surface.build_surface(tri, angle, weights, return_edge_colours = True) assert strata[i] == carried_surface.stratum_from_weights_surface(weights, surface) veering_isoms = carried_surface.veering_symmetry_group(surface, edge_colours) assert len(veering_isoms) == orders_of_veering_symmetry_groups[i] isom = veering_isoms[1] mutation.mutate(tri, angle, weights, isom, quiet = True) if i == 0: assert tri.isoSig() == 'ivLLQQccfhfeghghwadiwadrv' #print('svof to wadrv passed') elif i == 1: assert tri.isoSig() == 'jvLLAQQdfghhfgiiijttmtltrcr' #print('smkutn to tltrcr passed') elif i == 2: assert tri.isoSig() == 'jLLMvQQcedehhiiihiikiwnmtxk' #print('smkutn to mtxk passed') elif i == 3: assert tri.isoSig() == 'jLLALMQcecdhggiiihqrwqwrafo' #print('spiq to rafo passed') if sage_working: print("all tests depending on sage passed")