# Detecting genus in vertex links for the fast enumeration of 3-manifold triangulations

## Abstract

Enumerating all 3-manifold triangulations of a given size is a difficult but increasingly important problem in computational topology. A key difficulty for enumeration algorithms is that most combinatorial triangulations must be discarded because they do not represent topological 3-manifolds. In this paper we show how to preempt bad triangulations by detecting genus in partially-constructed vertex links, allowing us to prune the enumeration tree substantially.

The key idea is to manipulate the boundary edges surrounding partial vertex links using expected logarithmic time operations. Practical testing shows the resulting enumeration algorithm to be significantly faster, with up to speed-ups even for small problems where comparisons are feasible. We also discuss parallelisation, and describe new data sets that have been obtained using high-performance computing facilities.

**ACM classes** G.2.1; G.4; I.1.2

**Keywords** Computational topology, 3-manifolds, triangulations, census algorithm, combinatorial enumeration

## 1Introduction

In computational geometry and topology, triangulations are natural and ubiquitous data structures for representing topological spaces. Here we focus on triangulations in 3-manifold topology, an important branch of topology in which many key problems are theoretically decidable but extremely difficult for practical computation [1].

A *census* of 3-manifold triangulations is a list of all triangulations that satisfy some given set of properties. A typical census fixes the number of tetrahedra (the *size* of the triangulation), and enumerates all triangulations up to *isomorphism* (a relabelling of the tetrahedra and their vertices).

Censuses of this type first appeared in the late 1980s [14].^{1}*minimal triangulations*, which represent a given 3-manifold using the fewest possible tetrahedra. Such censuses have brought about new insights into the combinatorics of minimal triangulations [9] and the complexities of 3-manifolds [17], and have proven useful for computation and experimentation [4].

A more recent development has been censuses of *all* possible 3-manifold triangulations of a given size, including non-minimal triangulations [11]. These have yielded surprising experimental insights into algorithmic complexity problems and random 3-manifold triangulations [11], both topics which remain extremely difficult to handle theoretically.

The limits of censuses in the literature are fairly small. For closed -irreducible 3-manifolds, all minimal triangulations have been enumerated for only tetrahedra [8]; for the orientable case only, the list of manifolds (but not triangulations) is known for tetrahedra [23]. A full list of all closed 3-manifold triangulations (non-minimal included) is known for just tetrahedra [11]. These small limits are unavoidable because censuses grow exponentially—and sometimes super-exponentially [12]—in size.

Nevertheless, in theory it should be possible to extend these results substantially. Census algorithms are typically based on a recursive search through all possible *combinatorial triangulations*—that is, methods of gluing together faces of tetrahedra in pairs. However, as the number of tetrahedra grows large, almost all combinatorial triangulations are *not* 3-manifold triangulations [13]. The problem is that *vertex links*—boundaries of small neighbourhoods of the vertices of a triangulation—are generally not spheres or discs as they should be, but instead higher-genus surfaces.

To illustrate: for tetrahedra, if we simply glue together all tetrahedron faces in pairs, a very rough estimate (described in the appendix) gives at least connected *combinatorial* triangulations up to isomorphism. However, just 139 103 032 are *3-manifold* triangulations [11], and a mere 3 338 are minimal triangulations of closed -irreducible 3-manifolds [8].

It is clear then that large branches of the combinatorial search tree can be avoided, if one could only identify *which* branches these are. The current challenge for enumeration algorithms is to find new and easily-testable conditions under which such branches can be pruned.

For censuses of minimal triangulations, several such conditions are known: examples include the absence of low-degree edges [6], or of “bad subgraphs” in the underlying 4-valent face pairing graph [8]. Nevertheless, seeing how few minimal triangulations are found in practice, there are likely many more conditions yet to be found.

It is critical that such conditions can be tested quickly, since these tests are run on a continual basis as the search progresses and backtracks. The paper [8] introduces a modified union-find framework through which several minimality tests can be performed in time. Importantly, this framework can also be used with censuses of *all* 3-manifold triangulations (non-minimal included), where it is used to test that: (i) partially-constructed vertex links are orientable, and (ii) fully-constructed edges are not identified with themselves in reverse. Although tests (i) and (ii) are powerful when enumerating *non-orientable* triangulations, they do not help for *orientable* triangulations because they are already enforced by the overall enumeration algorithm.

The main contributions of this paper are:

We add the following condition to the suite of tests used during enumeration:

*all partially-constructed vertex links must be punctured spheres*(not punctured higher-genus surfaces).Although this condition is straightforward, it has traditionally required operations to test, making it impractical for frequent use in the enumeration algorithm. In Section 3 we show how to test this condition

*incrementally*, using only expected logarithmic-time operations at each stage of the combinatorial search.This condition is extremely powerful in both the orientable and non-orientable cases, and our new incremental test makes it practical for real use. Performance testing in Section 4 shows speed-ups of up to even for small enumeration problems where experimental comparisons are feasible ().

In Section 6 we use this to obtain new census data, including all closed 3-manifold triangulations of size (non-minimal included, improving the previous limit of ), and all minimal triangulations of closed -irreducible 3-manifolds of size (improving the previous limit of ). High-performance computing and distributed algorithms play a key role, as outlined in Section 5. All censuses cover both orientable and non-orientable triangulations.

This new census data is already proving useful in ongoing projects, such as studying the structure of minimal triangulations, and mapping out average-case and generic complexities for difficult topological decision problems.

It should be noted that avoiding isomorphisms—often a significant difficulty in combinatorial enumeration—is not a problem here. See the full version of this paper for details.

Looking forward, the techniques of this paper can also be applied to the enumeration of *4-manifold* triangulations. In this higher-dimensional setting, our techniques can be applied to edge links rather than vertex links. Vertices on the other hand become more difficult to handle: each vertex link must be a 3-sphere, and 3-sphere recognition remains a difficult algorithmic problem [12]. Here research into algebraic techniques may yield new heuristics to further prune the search tree.

Throughout this paper we restrict our attention to closed 3-manifolds, although all of the results presented here extend easily to manifolds with boundary.

All algorithms described in this paper can be downloaded as part of *Regina* [5], an open-source software package for the algebraic and combinatorial manipulation of 3-manifolds and their triangulations.

## 2Preliminaries

Consider a collection of tetrahedra (these are abstract objects, and need not be embedded in some ). A *combinatorial triangulation* of *size * is obtained by affinely identifying (or “gluing together”) the tetrahedron faces in pairs.^{2}

a partition of the tetrahedron faces into pairs, indicating which faces are to be identified;

permutations of three elements, indicating which of the six possible rotations or reflections is to be used for each identification.

For instance, consider the following example with tetrahedra. The tetrahedra are labelled , and the four vertices of each tetrahedron are labelled .

The top-left cell of this table indicates that face of tetrahedron is identified with face of tetrahedron , using the rotation or reflection that maps vertices of tetrahedron to vertices of tetrahedron respectively. For convenience, the same identification is also shown from the other direction in the second cell of the bottom row.

As a consequence of these face identifications, we find that several tetrahedron edges become identified together; each such equivalence class is called an *edge of the triangulation*. Likewise, each equivalence class of identified vertices is called a *vertex of the triangulation*. The triangulation illustrated above has three edges and just one vertex.

The *face pairing graph* of a combinatorial triangulation is the 4-valent multigraph whose nodes represent tetrahedra and whose edges represent face identifications. The face pairing graph for the example above is shown in Figure 1. A combinatorial triangulation is called *connected* if and only if its face pairing graph is connected.

The *vertex links* of a triangulation are obtained as follows. In each tetrahedron we place four triangles surrounding the four vertices, as shown in Figure 2. We then glue together the edges of these triangles in a manner consistent with the face identifications of the surrounding tetrahedra, as illustrated in Figure 3.

The result is a collection of triangulated closed surfaces, one surrounding each vertex of the triangulation. The surface surrounding vertex is referred to as the *link of *. Topologically, this represents the boundary of a small neighbourhood of in the triangulation.

A *3-manifold triangulation* is a combinatorial triangulation that, when viewed as a topological space, represents a 3-manifold. Equivalently, a 3-manifold triangulation is a combinatorial triangulation in which:

each vertex link is a topological sphere;

no tetrahedron edge is identified with itself in reverse as a result of the face identifications.

^{3}

The earlier example is *not* a 3-manifold triangulation, since the link of the (unique) vertex is a torus, not a sphere. For many 3-manifolds , the size of a minimal triangulation of corresponds to the Matveev complexity of [17].

A *partial triangulation* is a combinatorial triangulation in which we identify only of the tetrahedron faces in pairs, for some . We define vertices, edges and vertex links as before, noting that vertex links might now be surfaces with boundary (not closed surfaces).

A typical enumeration algorithm works as follows [8]:

There is also the problem of avoiding isomorphisms. This is computationally cheap if the recursion is ordered carefully; for details, see the full version of this paper.

In practice, step 1 is negligible—almost all of the computational work is in the recursive search (steps 2–4). The tests in step 3 are critical: they must be extremely fast, since they are run at every stage of the recursive search. Moreover, if chosen carefully, these tests can prune vast sections of the search tree and speed up the enumeration substantially.

A useful observation is that some graphs can be eliminated immediately after step 1. See [6] for algorithms that incorporate such techniques.

## 3Tracking Vertex Links

In this paper we add the following test to step 3 of the enumeration algorithm:

Theoretically, it is simple to show that this test works:

Suppose we *can* glue the remaining faces together to form a 3-manifold triangulation . Let and be the links of in and respectively; since is a 3-manifold triangulation, must be a topological sphere.

This link is obtained from by attaching zero or more additional triangles. Therefore is an embedded subsurface of the sphere, and so must be a sphere with zero or more punctures.

The test itself is straightforward; the difficulty lies in performing it *quickly*. A fast implementation is crucial, since it will be called repeatedly throughout the recursive search.

The key idea is to track the 1-dimensional *boundary curves* of the vertex links, which are formed from cycles of edges belonging to vertex-linking triangles. As we glue tetrahedron faces together, we repeatedly split and splice these boundary cycles. To verify Test ?, we must track which triangles belong to the same vertex links and which edges belong to the same boundary cycles, which we can do in expected logarithmic time using union-find and skip lists respectively.

In the sections below, we describe what additional data needs to be stored (Section Section 3.1), how to manipulate and use this data (Section Section 3.2), and how skip lists can ensure a small time complexity (Section Section 3.3).

### 3.1Data structures

In a partial triangulation with tetrahedra, there are *vertex linking triangles* that together form the vertex links (four such triangles are shown in Figure 2). These triangles are surrounded by a total of *vertex linking edges*.

Each time we glue together two tetrahedron faces, we consequently glue together three pairs of vertex linking edges, as shown in Figure 3. This gradually combines the triangles into a collection of larger triangulated surfaces, as illustrated in Figure 4. The boundary curves of these surfaces are drawn in bold in Figure 4; these are formed from the vertex linking edges that have not yet been paired together.

To support Test ?, we store all vertex linking edges in a series of cyclic list structures that describe these boundary curves. To simplify the discussion, we begin with a naïve implementation based on doubly-linked lists. However, this leaves us with an operation to perform, as seen in Section 3.2. To run all operations in expected logarithmic time we use skip lists [25], which we outline in Section 3.3.

We treat the vertex linking edges as *directed edges* (i.e., arrows), with directions chosen arbitrarily at the beginning of the enumeration algorithm. For each vertex linking edge , we store the following data:

If is part of a boundary curve, we store the two edges adjacent to along this boundary curve, as well as two booleans that tell us whether these adjacent edges point in the same or opposite directions.

If is not part of a boundary curve (i.e., it has been glued to some other vertex linking edge and is now internal to a vertex linking surface), we store a snapshot of the above data from the last time that

*was*part of a boundary curve.

To summarise: edges on the boundary curves are stored in a series of doubly-linked lists, and internal edges remember where they *were* in these lists right before they were glued to their current partner.

### 3.2Recursion, backtracking and testing

Recall that each time we glue two tetrahedron faces together, we must glue together *three* pairs of vertex linking edges. Each of these edge gluings changes the vertex linking surfaces, and so we process each edge gluing individually.

There are three key operations that we must perform in relation to edge gluings:

gluing two vertex linking edges together (when we step forward in the recursion);

ungluing two vertex linking edges (when we backtrack);

verifying Test ? after gluing two vertex linking edges together (i.e., verifying that all vertex links are spheres with zero or more punctures).

We now present the details of each operation in turn. Throughout this discussion we assume that edges are glued together so that all vertex links are *orientable* surfaces; the paper [8] describes an efficient framework for detecting non-orientable vertex links as soon as they arise.

#### Recursion: gluing edges together

Suppose we wish to glue together edges and , as illustrated in Figure 5. Only local modifications are required: edges and become adjacent and must now to link to each other (instead of to and ); likewise, edges and must be adjusted to link to each other. Note that this gluing introduces a change of direction where and meet (and likewise for and ), so as we adjust the direction-related booleans we must perform an extra negation on each side.

We make no changes to the data stored for edges and , since these two edges are now internal and their associated data now represents a snapshot from the last time that they were boundary edges (as required by Section 3.1).

All of these local modifications can be performed in time. The associated list operations are deletion, splitting and splicing; this becomes important when we move to skip lists in Section 3.3.

It is important to remember the special case in which edges and are adjacent in the same boundary cycle. Here the local modifications are slightly different (there are only two or possibly zero nearby edges to update instead of four), but these modifications remain time.

#### Backtracking: ungluing edges

As with gluing, ungluing a pair of vertex linking edges is a simple matter of local modifications. Here the backtracking context is important: it is essential that we unglue edges in the reverse order to that in which they were glued.

Suppose we are ungluing edges and as depicted in Figure 5. The snapshot data stored with edges and shows that they *were* adjacent to edges , , and immediately before this gluing was made (and therefore immediately *after* the ungluing that we are now performing).

This snapshot data therefore gives us access to edges , , and : now we simply adjust and to link to (instead of and ), and likewise we adjust and to link to . No modifications to edges and are required.

Again we must adjust the direction-related booleans carefully, and we must cater for the case in which edges and were adjacent immediately before the gluing was made.

As before, all local modifications can be performed in time. For the skip list discussion in Section 3.3, the associated list operations are splitting, splicing and insertion.

#### Testing: verifying that links are punctured spheres

Each time we glue two vertex linking edges together we must ensure that every vertex link is a sphere with zero or more punctures (Test ?). We test this *incrementally*: we assume this is true *before* we glue these edges together, and we verify that our new gluing does not introduce any unwanted genus to the vertex links.

Our incremental test is based on the following two observations:

The proofs of Lemmata ? and ? are simple, and we do not give further details here. Figure ? illustrates the scenario of Lemma ? with two distinct punctured spheres, and Figures ?– ? show different scenarios from Lemma ? in which we join two boundary edges from the same punctured sphere.

In particular, Figure ? shows the case in which and belong to different boundary cycles; here we observe that the resulting surface is a twice-punctured torus. Figures ? and ? show cases with and on the same boundary cycle; in ?, and are adjacent along the boundary.

Note that Lemmata ? and ? hold even with very short boundaries (for instance, one-edge boundaries consisting of or alone).

It is now clear how to incrementally verify Test ? when we glue together vertex linking edges and :

Test whether the vertex linking triangles containing and belong to the same connected vertex linking surface. If not, the test passes. Otherwise:

Test whether and belong to the same doubly-linked list of boundary edges (i.e., the same boundary cycle). If so, the test passes. If not, the test fails.

Here we implicitly assume that all gluings are orientation-preserving, as noted at the beginning of Section 3.2.

Step 1 can be performed in time using the modified union-find structure outlined in [8]. The original purpose of this structure was to enforce orientability in vertex linking surfaces, and one of the operations it provides is an test for whether two vertex linking triangles belong to the same connected vertex linking surface. This modified union-find supports backtracking; see [8] for further details.

Step 2 is more difficult: a typical implementation might involve walking through the doubly-linked list containing until we either find or verify that is not present, which takes time to complete. Union-find cannot help us, because of our repeated splitting and splicing of boundary cycles. In the following section we show how to reduce this running time to expected by extending our doubly-linked lists to become *skip lists*.

It should be noted that Step 2 can in fact be carried out in time, where is the number of boundary edges on all vertex linking surfaces. Although in general, for some face pairing graphs can be far smaller. For instance, when the face pairing graph is a double-ended chain [6], we can arrange the recursive search so that . See the full version of this paper for details.

### 3.3Skip lists and time complexity

From the discussion in Section 3.2, we see that with our naïve doubly-linked list implementation, the three key operations of gluing edges, ungluing edges and verifying Test ? have , and running times respectively. The bottleneck is the test for whether two vertex linking edges belong to the same doubly-linked list (i.e., the same boundary cycle).

We can improve our situation by extending our doubly-linked list to a *skip list* [25]. Skip lists are essentially linked lists with additional layers of “express pointers” that allow us to move quickly through the list instead of stepping forward one element at a time. Figure 6 shows a typical skip list structure.

The list operations used in Section 3.2 for gluing and ungluing edges are deletion, insertion, splitting and splicing; all of these can be performed on a skip list in expected time [24]. Importantly, it also takes expected time to search forward to the last element of a skip list.^{4}

It follows that, with a skip list implementation, all three key operations of gluing edges, ungluing edges and verifying Test ? run in expected time. Therefore:

Note that we must include reverse links at the lowest layer of the skip list (effectively maintaining the original doubly-linked list), since both forward and backward links are required for the gluing and ungluing operations (see Section 3.2). Full details of the skip list implementation can be found in the full version of this paper.

## 4Performance

Here we measure the performance of our new algorithm experimentally. Specifically, we compare two enumeration algorithms: the *old algorithm*, which includes all of the optimisations described in [8] (including the union-find framework for ensuring that vertex links remain orientable), and the *new algorithm*, which enhances the old algorithm with the new tests described in Section 3.^{5}

We run our performance tests by enumerating censuses of all 3-manifold triangulations of size . We choose this type of census because a census of minimal triangulations requires significant manual post-processing [8], and because a census of all triangulations is significantly larger and therefore a stronger “stress test”. We restrict our tests to because for larger the old algorithm becomes too slow to run time trials on a single CPU.

, orientable | 4 807 | 0:59 | 0:03 | |

, non-orientable | 377 | 1:09 | 0:06 | |

[1ex] , orientable | 52 946 | 1:11:57 | 1:03 | |

, non-orientable | 4 807 | 1:23:30 | 2:05 | |

[1ex] , orientable | 658 474 | 92:23:39 | 22:16 | |

, non-orientable | 64 291 | 103:24:51 | 48:27 |

Table 1 shows the results of our time trials, split into censuses of orientable and non-orientable triangulations. For both algorithms run in 1 second or less. All trials were carried out on a single 2.93 GHz Intel Xeon X5570 CPU.

The results are extremely pleasing: for we see a speed-up of in the non-orientable case and in the orientable case (from almost four days of running time down to just 22 minutes). Moreover, the speed-up factors appear to grow exponentially with . All of this suggests that our new algorithm can indeed make a concrete difference as to how large a census we can feasibly build.

It is worth noting that speed-ups are consistently better for the orientable case. This may be because the union-find framework introduced in [8] is most effective for non-orientable enumeration (as noted in Section 1), and so the orientable case has more room for gain. Nevertheless, it is pleasing to see that the new algorithm gives substantial improvements for both the orientable and non-orientable cases.

## 5Parallelisation

As increases, the output size for a typical census grows exponentially in , and sometimes super-exponentially—for instance, the growth rate of a census of all 3-manifold triangulations is known to be [12]. It is therefore critical that enumeration algorithms be parallelised if we are to make significant progress in obtaining new census data.

Like many combinatorial searches, the enumeration of triangulations is an embarrassingly parallel problem: different branches of the search tree can be processed independently, making the problem well-suited for clusters and server farms. Avoiding isomorphisms causes some minor complications, which we discuss in the full version of this paper.

The main obstacle is that, because of the various pruning techniques (as described in Sections Section 2 and Section 3), it is very difficult to estimate in advance how long each branch of the search tree will take to process. Experience shows that there can be orders-of-magnitude differences in running time between subsearches at the same depth in the tree.

For this reason, parallelisation must use a controller / slave model in which a controller process repeatedly hands small pieces of the search space to the next available slave, as opposed to a simple subdivision in which each process handles a fixed portion of the search space. This means that some inter-process communication is required.

For each subsearch, the controller must send data to the slave: this includes the face pairing graph, the partial triangulation, and the data associated with the vertex linking edges and triangles as described in Section 3. The output for each subsearch can be super-exponentially large, and so it is preferable for slaves to write this data directly to disk (as opposed to communicating it back to the controller). Collating the output from different slaves is a simple task that can be performed after the enumeration has finished.

The enumeration code in *Regina* implements such a model using MPI, and runs successfully on hundreds of simultaneous CPUs with a roughly proportional speed-up in wall time.

## 6Census Data

The new algorithms in this paper have been implemented and run in parallel using high-performance computing facilities to obtain new census data that exceeds the best known limits in the literature. This includes (i) a census of all closed 3-manifold triangulations of size , and (ii) a census of all minimal triangulations of closed -irreducible 3-manifolds of size .

### 6.1All closed 3-manifold triangulations

The first reported census of all closed 3-manifold triangulations appears in [11] for , and has been used to study algorithmic complexity and random triangulations [11]. Here we extend this census to with a total of over 2 billion triangulations:

Size () | Orientable | Non-orientable | Total |
---|---|---|---|

1 | 4 | — | 4 |

2 | 16 | 1 | 17 |

3 | 76 | 5 | 81 |

4 | 532 | 45 | 577 |

5 | 4 807 | 377 | 5 184 |

6 | 52 946 | 4 807 | 57 753 |

7 | 658 474 | 64 291 | 722 765 |

8 | 8 802 955 | 984 554 | 9 787 509 |

9 | 123 603 770 | 15 499 262 | 139 103 032 |

10 | 1 792 348 876 | 254 521 123 | 2 046 869 999 |

Total | 1 925 472 456 | 271 074 465 | 2 196 546 921 |

The total CPU time required to enumerate the 10-tetrahedron census was years, divided amongst 192 distinct 2.93 GHz Intel Xeon X5570 CPUs.

The paper [11] makes two conjectures regarding the worst-case and average number of vertex normal surfaces for a closed 3-manifold triangulation of size . Details and definitions can be found in [11]; in summary, these conjectures are:

These conjectures were originally based on the census data for . With our new census we can now verify these conjectures at the 10-tetrahedron level:

This census contains over 63 GB of data, and so the data files have not been posted online. Readers who wish to work with this data are welcome to contact the author for a copy.

### 6.2Closed -irreducible 3-manifolds

A 3-manifold is *-irreducible* if every sphere bounds a ball and there are no embedded two-sided projective planes. Censuses of closed -irreducible 3-manifolds and their minimal triangulations have a long history [2]. The largest reported census of all minimal *triangulations* of these manifolds reaches [8]. If we enumerate *manifolds* but not their triangulations, the censuses reaches in the orientable case [23] but remains at in the non-orientable case.

Here we extend this census of minimal triangulations of closed -irreducible 3-manifolds to . As a result, we also extend the census of underlying manifolds to in the non-orientable case, and in the orientable case we confirm that the number of manifolds matches Matveev’s census [23].

Size | ||||

() | Orientable | Non-orient. | Orientable | Non-orient. |

1 | 4 | — | 3 | — |

2 | 9 | — | 6 | — |

3 | 7 | — | 7 | — |

4 | 15 | — | 14 | — |

5 | 40 | — | 31 | — |

6 | 115 | 24 | 74 | 5 |

7 | 309 | 17 | 175 | 3 |

8 | 945 | 59 | 436 | 10 |

9 | 3 031 | 307 | 1 154 | 33 |

10 | 10 244 | 983 | 3 078 | 85 |

11 | 36 097 | 3 282 | 8 421 | 230 |

Total | 50 816 | 4 672 | 13 399 | 366 |

The paper [9] raises conjectures for certain classes of non-orientable 3-manifolds regarding the combinatorial structure of every minimal triangulation. Again we refer to the source [9] for details and definitions; in summary:

Layered torus bundles and plugged thin and thick -bundles are families of triangulations with well-defined combinatorial structures. The original conjectures were based on census data for , and in [8] they are shown to hold for all . With our new census data we are now able to validate these conjectures at the 11-tetrahedron level:

Data files for this census, including the 3-manifolds and all of their minimal triangulations, can be downloaded from the *Regina* website [5].

## Acknowledgments

Computational resources used in this work were provided by the Queensland Cyber Infrastructure Foundation and the Victorian Partnership for Advanced Computing.

Benjamin A. Burton

School of Mathematics and Physics, The University of Queensland

Brisbane QLD 4072, Australia

(bab@maths.uq.edu.au)

## Appendix

In the introduction we claim there are at least connected combinatorial triangulations of size , up to isomorphism. Here we give the arguments to support this claim.

We begin by placing a lower bound on the number of *labelled* connected combinatorial triangulations. To ensure that each triangulation is connected, we insist that the first face of tetrahedron is glued to some face chosen from tetrahedra , for all . Of course there are many labelled connected triangulations that do not satisfy this constraint, but since we are computing a lower bound this does not matter.

We initially choose gluings for the first face of each tetrahedron in order. For the first face of tetrahedron there are choices for a partner face—these are the faces of tetrahedra minus the faces already glued—as well as six choices of rotation or reflection. This gives a total of possibilities. From here there are ways of gluing together the remaining faces in pairs, giving a lower bound of at least labelled connected combinatorial triangulations of size .

We finish by factoring out isomorphisms. Each isomorphism class has size at most (all possible relabellings of tetrahedra and their vertices), and so the total number of connected combinatorial triangulations of size *up to isomorphism* is at least

For this evaluates to approximately .

### Footnotes

- Some authors, following Matveev [19], work in the setting of
*special spines*which are dual to triangulations. - A combinatorial triangulation need not be a simplicial complex, and need not represent a topological 3-manifold. The word “combinatorial” indicates that we are only interested in face identifications, with no topological requirements.
- An equivalent condition to (ii) is that we can direct the edges of every tetrahedron in a manner consistent with the face identifications.
- Although our lists are cyclic, we can always define an arbitrary endpoint.
- We compare the new algorithm against [8] because this allows us to isolate our new techniques, and because the source code and implementation details for alternative algorithms [16] are not readily available.

### References

- Ian Agol, Joel Hass, and William Thurston,
*3-manifold knot genus is NP-complete*, STOC ’02: Proceedings of the Thiry-Fourth Annual ACM Symposium on Theory of Computing, ACM Press, 2002, pp. 761–766. - Gennaro Amendola and Bruno Martelli,
*Non-orientable 3-manifolds of small complexity*, Topology Appl.**133**(2003), no. 2, 157–178. - to3em,
*Non-orientable 3-manifolds of complexity up to 7*, Topology Appl.**150**(2005), no. 1-3, 179–195. - Ryan Budney,
*Embeddings of 3-manifolds in from the point of view of the 11-tetrahedron census*, Preprint,`arXiv: 0810.2346`

, October 2008. - Benjamin A. Burton,
*Regina: Normal surface and 3-manifold topology software*,`http://regina. sourceforge.net/`

, 1999–2010. - to3em,
*Face pairing graphs and 3-manifold enumeration*, J. Knot Theory Ramifications**13**(2004), no. 8, 1057–1101. - to3em,
*Introducing Regina, the 3-manifold topology software*, Experiment. Math.**13**(2004), no. 3, 267–272. - to3em,
*Enumeration of non-orientable 3-manifolds using face-pairing graphs and union-find*, Discrete Comput. Geom.**38**(2007), no. 3, 527–571. - to3em,
*Observations from the 8-tetrahedron nonorientable census*, Experiment. Math.**16**(2007), no. 2, 129–144. - to3em,
*Converting between quadrilateral and standard solution sets in normal surface theory*, Algebr. Geom. Topol.**9**(2009), no. 4, 2121–2174. - to3em,
*The complexity of the normal surface solution space*, SCG ’10: Proceedings of the Twenty-Sixth Annual Symposium on Computational Geometry, ACM, 2010, pp. 201–209. - to3em,
*The Pachner graph and the simplification of 3-sphere triangulations*, To appear in SCG ’11: Proceedings of the Twenty-Seventh Annual Symposium on Computational Geometry,`arXiv: 1011.4169`

, November 2010. - Nathan M. Dunfield and William P. Thurston,
*Finite covers of random 3-manifolds*, Invent. Math.**166**(2006), no. 3, 457–521. - Martin V. Hildebrand and Jeffrey R. Weeks,
*A computer generated census of cusped hyperbolic 3-manifolds*, Computers and Mathematics (Cambridge, MA, 1989), Springer, New York, 1989, pp. 53–59. - Bruno Martelli,
*Complexity of 3-manifolds*, Spaces of Kleinian Groups, London Math. Soc. Lecture Note Ser., vol. 329, Cambridge Univ. Press, Cambridge, 2006, pp. 91–120. - Bruno Martelli and Carlo Petronio,
*Three-manifolds having complexity at most 9*, Experiment. Math.**10**(2001), no. 2, 207–236. - to3em,
*A new decomposition theorem for 3-manifolds*, Illinois J. Math.**46**(2002), 755–780. - to3em,
*Complexity of geometric three-manifolds*, Geom. Dedicata**108**(2004), no. 1, 15–69. - S. V. Matveev and A. T. Fomenko,
*Constant energy surfaces of Hamiltonian systems, enumeration of three-dimensional manifolds in increasing order of complexity, and computation of volumes of closed hyperbolic manifolds*, Russian Math. Surveys**43**(1988), no. 1, 3–24. - Sergei Matveev,
*Algorithmic topology and classification of 3-manifolds*, Algorithms and Computation in Mathematics, no. 9, Springer, Berlin, 2003. - Sergei V. Matveev,
*Tables of 3-manifolds up to complexity 6*, Max-Planck-Institut für Mathematik Preprint Series (1998), no. 67, available from`http://www.mpim-bonn. mpg.de/html/preprints/ preprints.html`

. - to3em,
*Recognition and tabulation of three-dimensional manifolds*, Dokl. Akad. Nauk**400**(2005), no. 1, 26–28. - to3em,
*Tabulation of three-dimensional manifolds*, Russian Math. Surveys**60**(2005), no. 4, 673–698. - William Pugh,
*A skip list cookbook*, Report UMIACS- TR-89-72.1, Univ. of Maryland Institute for Advanced Computer Studies, College Park, MD, USA, 1990. - to3em,
*Skip lists: A probabilistic alternative to balanced trees*, Commun. ACM**33**(1990), no. 6, 668–676.