# Fixed parameter tractable algorithms in combinatorial topology

## Abstract

To enumerate 3-manifold triangulations with a given property, one typically begins with a set of potential face pairing graphs (also known as dual 1-skeletons), and then attempts to flesh each graph out into full triangulations using an exponential-time enumeration. However, asymptotically most graphs do not result in *any* 3-manifold triangulation, which leads to significant “wasted time” in topological enumeration algorithms. Here we give a new algorithm to determine whether a given face pairing graph supports any 3-manifold triangulation, and show this to be fixed parameter tractable in the treewidth of the graph.

We extend this result to a “meta-theorem” by defining a broad class of properties of triangulations, each with a corresponding fixed parameter tractable existence algorithm. We explicitly implement this algorithm in the most generic setting, and we identify heuristics that in practice are seen to mitigate the large constants that so often occur in parameterised complexity, highlighting the practicality of our techniques.

## 1Introduction

In combinatorial topology, a triangulated 3-manifold involves abstract tetrahedra whose faces are identified or “glued” in pairs. Many research questions involve looking for a triangulated manifold which fits certain requirements, or is pathologically bad for certain algorithms, or breaks some conjecture. One invaluable tool for such tasks is an exhaustive *census* of triangulated 3-manifolds.

The first of these was the census of cusped hyperbolic 3-manifold triangulations on tetrahedra by Hildebrand and Weeks [17] in 1989, later extended to tetrahedra [8]. Another much-used example is the census of closed orientable prime minimal triangulations of tetrahedra by Matveev [23], later extended to tetrahedra [21].

In all of these prior works, the authors enumerate all triangulated manifolds on tetrahedra by first enumerating all 4-regular multigraphs on nodes (very fast), and then for each graph essentially modelling every possible triangulation with as its dual graph (very slow). If any such triangulation built from is the triangulation of a 3-manifold, we say that is *admissible*. If admits a 3-manifold triangulation with some particular property , we say that is *p-admissible*.

Using state-of-the-art public software [9], generating such a census on 12 tetrahedra takes 1967 CPU-days, of which over 1588 CPU-days is spent analysing non-admissible graphs. Indeed, for a typical census on tetrahedra, less than of -regular graphs are admissible [7]. Moreover, Dunfield and Thurston [16] show that the probability of a random 4-regular graph being admissible tends toward zero as the size of the graph increases. Clearly an efficient method of determining whether a given graph is admissible could have significant effect on the (often enormous) running time required to generating such a census.

We use parameterized complexity [15] to address this issue. A problem is *fixed parameter tractable* if, when some parameter of the input is fixed, the problem can be solved in polynomial time in the input size. In Theorem ? we show that to test whether a graph is admissible is fixed parameter tractable, where the parameter is the treewidth of . Specifically, if the treewidth is fixed at and has size , we can determine whether is admissible in time.

Courcelle showed [14] that for graphs of bounded treewidth, an entire class of problems have fixed parameter tractable algorithms. However, employing this result for our problem of testing admissibility looks to be highly non-trivial. In particular, it is not clear how the topological constraints of our problem can be expressed in monadic second-order logic, as Courcelle’s theorem requires. Even if Courcelle’s theorem could be used, our results here provide significantly better constants than a direct application of Courcelle’s theorem would.

Following the example of Courcelle’s theorem, however, we generalise our result to a larger class of problems (Theorem ?). Specifically, we introduce the concept of a *simple property*, and give a fixed parameter tractable algorithm which, for any simple property , determines whether a graph admits a triangulated 3-manifold with property (again the parameter is treewidth).

We show that these results are practical through an explicit implementation, and identify some simple heuristics which improve the running time and memory requirements. To finish the paper, we identify a clear potential for how these ideas can be extended to the more difficult enumeration problem, in those cases where a graph *is* admissible and a complete list of triangulations is required.

Parameterised complexity is very new to the field of 3-manifold topology [10], and this paper marks the first exploration of parameterised complexity in 3-manifold enumeration problems. Given that 3-manifold algorithms are often extremely slow and complex, our work here highlights a growing potential for parameterised complexity to offer practical alternative algorithms in this field.

## 2Background

To avoid ambiguity with the words “vertex” and “edge”, we use the terms *node* and *arc* instead for graphs, and *vertex* and *edge* in the context of triangulations.

Many NP-hard problems on graphs are fixed parameter tractable in the *treewidth* of the graph (e.g., [1]). Introduced by Robertson and Seymour [25], the treewidth measures precisely how “tree-like” a graph is:

Bodlaender [4] gave a linear time algorithm for determining if a graph has treewidth for fixed , and for finding such a tree decomposition, and Kloks [20] demonstrated algorithms for finding “nice” tree decompositions.

A closed 3-manifold is essentially a topological space in which every point has some small neighbourhood homeomorphic to . We first define *general triangulations*, and then give conditions under which they represent 3-manifolds.

Note that this is more general than a simplicial complex (e.g., we allow an identification between two distinct faces of the same tetrahedron), and it need not represent a 3-manifold. Any face which is not identified to another face is called a *boundary face* of the triangulation. If a triangulation has no such boundary faces, we say it is *closed*. We also note that there are six ways to identify two faces, given by the six symmetries of a regular triangle.

We can partially represent a triangulation by its face pairing graph, which describes *which* faces are identified together, but not *how* they are identified.

Note that a face pairing graph will have parallel arcs if there are two distinct face identifications between and , and loops if two faces of the same tetrahedron are identified together.

Some edges of tetrahedra will be identified together as a result of these face identifications (and likewise for vertices). Some edges may be identified directly via a single face identification, while others may be identified indirectly through a series of face identifications.

We assign an arbitrary orientation to each edge of each tetrahedron. Given two tetrahedron edges and that are identified together via the face identifications, we write if the orientations agree, and if the orientations are reversed. In settings where we are not interested in orientation, we write if the two edges are identified (i.e. one of or holds).

This leads to the natural notation as an equivalence class of identified edges (ignoring orientation). We refer to as an *edge of the triangulation*. Likewise, we use the notation for vertices of tetrahedra that are identified together via the face identifications, and we call an equivalence class of identified vertices a *vertex of the triangulation*.

A *boundary edge / vertex* of a triangulation is an edge / vertex of the triangulation whose equivalence class contains some edge / vertex of a boundary face.

The *link* of a vertex is the (2-dimensional) frontier of a small regular neighbourhood of . Figure 1 shows the link of the top vertex shaded in grey; in this figure, the link is homeomorphic (topologically equivalent) to a disc. The link is a 2-dimensional triangulation (in the example it has six triangles), and we use the term *arc* to denote an edge in this triangulation. In this paper, whether “arc” refers to a graph or a vertex link is always clear from context.

These properties are necessary and sufficient for the underlying topological space to be a 3-manifold. We say that a graph is *admissible* if it is the face pairing graph for any closed 3-manifold triangulation .

These are in essence “partially constructed” 3-manifold triangulations; the algorithms of Section 4.1 build these up into full 3-manifold triangulations. Note that the underlying space of might not even be a 3-manifold with boundary: there may be “pinched vertices” whose links have many punctures.

We can make some simple observations: (i) the boundary vertices of a partial 3-manifold triangulation are precisely those whose links have at least one puncture; (ii) a connected partial-3-manifold triangulation with no boundary faces is a closed 3-manifold triangulation, and vice-versa; (iii) a partial-3-manifold triangulation with a face identification removed, or an entire tetrahedron removed, is still a partial-3-manifold triangulation.

## 3Configurations

The algorithms in Section 4.1 build up 3-manifold triangulations one tetrahedron at a time. As we add tetrahedra, we must track what happens on the boundary of the triangulation, but we can forget about the parts of the triangulation not on the boundary—this is key to showing fixed parameter tractability. In this section we define and analyse edge and vertex configurations of general triangulations, which encode exactly those details on the boundary that we must retain.

This mostly encodes the 2-dimensional triangulation of the boundary, though additional information describing “pinched vertices” is still required.

In partial-3-manifold triangulations, vertex links may have multiple punctures; the vertex configuration then allows us to deduce which punctures belong to the same link. In essence, the vertex configuration describes how the triangulation is “pinched” inside the manifold at vertices whose links have too many punctures.

For instance, the vertex configuration of Example ? is given by

The partition represents the pinch at the center of the “hockey puck”. We now give the boundary configuration of a triangulated cube on 5 tetrahedra as an additional example.

Note that must be even; let . Each boundary face has three edges, so there are possible pairs where is an edge on a boundary face . Each such pair must be identified with exactly one other pair, with either or , and so the number of possible edge configurations is

There are tetrahedron vertices on boundary faces, and so the number of possible vertex configurations is the Bell number . The result now follows from Lemma ? and the following inequality of Berend [3]:

The boundary configuration can be used to partially reconstruct the links of vertices on the boundary of the triangulation. In particular:

The edge configuration allows us to follow the arcs around each puncture of a vertex link—in Figure 2 for instance, we can follow the sequence of arcs that surround the puncture in the link of the top vertex.

The vertex configuration tells us whether two sequences of arcs describe punctures in the

*same*vertex link, versus*different*vertex links.

In this way, we can reconstruct all information about punctures in the vertex links, even though we cannot access the full (2-dimensional) triangulations of the links themselves. As the next result shows, this means that the boundary configuration retains all data required to build up a partial-3-manifold triangulation, without knowledge of the full triangulation of the underlying space.

We are given the boundary configuration for . We need to check that the new face identification does not result in any edges being identified in reverse, and that the links of all vertices are still spheres with zero or more punctures.

It is easy to see that the face identification will identify at most three pairs of boundary edges together, and it is routine to check (using the edge configuration) whether these identifications will result in any edge identified with itself in reverse in time. The rest of this proof therefore only deals with the vertex links.

To determine whether is also a partial-3-manifold triangulation we only need to determine how these new edge identifications affect the link of each vertex. Clearly any vertices that are internal to must already have links homeomorphic to a 2-sphere, and cannot be changed. We noted in Section 3 that the cycles of arcs surrounding the punctures on the links of each boundary vertex can be determined from the edge configuration—we do not explicitly reconstruct these cycles here, but we do note that this information is accessible from the edge configuration. We note also that each link of a boundary vertex in must be homeomorphic to a sphere with one or more punctures (equivalently, a disc with zero or more punctures).

The new face identification will identify three pairs of arcs on the vertex links, as shown in Figure 3. Each of these three arc identifications will take one of three forms (see Figure ?):

The two arcs being identified both bound the same puncture in the same vertex link.

The two arcs are part of the same vertex link but bound distinct punctures.

The two arcs are part of distinct vertex links.

For a type I identification, if the identification preserves the orientability of the vertex link then the new vertex link will be homeomorphic to a 2-sphere with zero or more punctures. In particular, if the puncture only contained two arcs and these are now both identified (in an orientable manner) then the puncture will be closed off (i.e., the vertex link will be a 2-sphere with one less puncture than before). If this vertex of the triangulation only had one puncture, then the vertex link will become homeomorphic to a 2-sphere and the new vertex will be an internal vertex of .

If orientability is not preserved in a type I identification then we will embed a Möbius band in the vertex link, which is never allowed. Identifications of type II increase the genus of the vertex link, which is likewise not allowed (see Figure ?), and identifications of type III simply connect two discs with zero or more punctures.

In summary: orientable identifications of type I and all identifications of type III are allowed, whereas non-orientable identifications of type I and all identifications of type II are not allowed.

Since the triangulations of all vertex links contain boundary arcs in total, we can identify both the type and orientation of each identification in time. Specifically, we use the edge configuration to determine if the identification is of type I (as well as the orientation of the identification), and we use the vertex configuration to distinguish between identifications of type II and type III. If any non-orientable type I identifications or any type II identifications are found, is not a partial-3-manifold triangulation.

Since we have only three such identifications of pairs of arcs, we can check all three in time as well. Combining this with the check described earlier for bad edges, we obtain the required result.

## 4Algorithms and simple properties

Recall that the motivating problem for our work was to quickly detect whether a given graph admits a closed 3-manifold triangulation. To this end we show:

This is a special case of our more general Theorem ?, and so we do not prove it in detail here. The basic idea is as follows.

We say that a boundary configuration is *viable* for a graph if there exists some partial-3-manifold triangulation with and with as its boundary configuration. Our algorithm starts with an empty triangulation, and then introduces tetrahedra and face identifications in a way that essentially works from the leaves up to the root of the tree decomposition of . For each subtree in the tree decomposition we compute which configurations are viable for the corresponding subgraph of , and then propagate these configurations further up the tree. The running time at each node depends only on the number of boundary faces, which is bounded in terms of the bag size and thereby .

### 4.1A generalisation to simple properties

Here we generalise Theorem ? to many other settings. For this we define a *simple property* of a partial 3-manifold triangulation (see below).

We extend boundary configurations to include an extra piece of data based on the partial triangulation that helps test our property. For instance, if is the simple property that the triangulation contains internal vertices, then might encode the number of internal vertices thus far in the partial 3-manifold triangulation (here takes one of the values ).

As before: for a simple property , we say that a boundary configuration is *-viable* for a graph if there exists some partial-3-manifold triangulation with property , with and with as its boundary configuration.

Shortly we solve the problem of testing whether a graph admits any closed 3-manifold triangulation with property , for any simple property . The basic idea is as before: for each subtree of our tree decomposition of , we compute all viable configurations and propagate this information up the tree.

The four conditions above can be respectively interpreted as meaning:

the upper bound on the number of viable configurations (including the data ) still depends on but not the number of tetrahedra;

we can still test property without examining the full triangulation;

new face identifications can still be checked for -viability in time;

configurations for disjoint triangulations can be combined in time.

We can now state the main result of this paper:

Our requirement for such a tree decomposition is not restrictive: Bodlaender [4] gives a fixed parameter tractable algorithm to find a tree decomposition of width for fixed , and Kloks [20] gives an time algorithm to transform this into a tree decomposition where each bag has at most two children. The “two children” constraint can be relaxed; we use it here to keep the proof simple.

We will give this proof in three sections. First, we describe the algorithm in detail. Then we show that the algorithm is correct. Lastly we demonstrate the running time of the algorithm.

We begin, however, with some preliminaries. Let the tree decomposition be . Recall that in a tree decomposition, each node of represents a collection of nodes of . We will use the term *bag* to refer to a node of , and *node* to refer to a node of . Each node in will represent a corresponding tetrahedron .

Arbitrarily choosing one bag of and make it the root bag, so that the tree becomes a hierarchy of subtrees. For each bag in , the subtree is defined as the subtree obtained by taking only the bag and any bag which appears below in .

We now define the subgraph of , which contains precisely those nodes of that appear *only* in . In other words, node is in if and only if does *not* appear in any bag in . The subgraph contains all corresponding arcs of , i.e., all arcs of that link nodes of .

We first make the following observation. If two children of some bag were to contain a common node , then since is a tree decomposition any such must also appear in the bag . Therefore *no two subgraphs may contain a common node representing a common tetrahedron*.

As a result, we can combine the boundary configurations of children of by simply taking the union of the configurations, as they correspond to disjoint triangulations. The same process can be used to extend some boundary configuration with the boundary configuration of a new standalone tetrahedron.

For each bag , we will construct all boundary configurations for . To achieve this, we take the following steps:

Take every possible combination of configurations from the children of , where each combination contains exactly one configuration from each child. We showed earlier that these must represent disjoint triangulations, and that for each combination we can construct the configuration of their union.

For each such combined configuration :

For each element inside the bag , if does not appear anywhere in a higher bag in , then add the boundary configuration of a single standalone tetrahedron (corresponding to tetrahedron ) to . Again, the earlier observation shows that this is possible. Then:

For each arc in incident to the node , if the other endpoint of the arc is also in , use Lemma ? to try to add each of the six possible corresponding face identifications to in turn (recall that these come from the six symmetries of a regular triangle). For each viable (but not necessarily -viable) configuration thus created, continue by recursing to Step ? and taking the next element .

If all elements of have been successfully processed in Step ? then a viable configuration has been found. Store this as a viable boundary configuration for .

If any bag contains no viable configurations, we immediately know that there are no closed 3-manifold triangulations satisfying -admissibility().

Once all configurations have been constructed, if the root bag contains any -viable boundary configurations (by construction all boundary configurations at the root node have empty edge and vertex configurations), then there does exist some closed 3-manifold triangulation with property such that . If, however, the root bag contains no -viable configuration then such a triangulation does not exist.

For each bag , we have a corresponding graph . If a closed 3-manifold triangulation with property and exists, then define to be the partial-3-manifold triangulation constructed by removing from the tetrahedra and face identifications which respectively represent nodes and arcs not present in . Each such must be a partial-3-manifold triangulation, and so each bag must have at least one viable configuration.

If the root bag does contain some -viable boundary configuration, then each arc in has been through Step ? in the algorithm and by Lemma ? we know that each such configuration must represent a partial 3-manifold triangulation with property (or possibly many such triangulations). Since is 4-regular, we also know that these triangulations can have no boundary faces, and so these partial 3-manifold triangulations must in fact be closed 3-manifold triangulations with property .

We begin by showing that the number of configurations at each bag is bounded by a function of , but is independent of .

Consider a boundary face of tetrahedron in some triangulation represented by some configuration in . In the graph , there must exist some arc which represents the identification of with some other face of some tetrahedron . However, since is a boundary face of , this must mean that the node representing must occur in some bag “higher up” in the tree decomposition; that is, the node representing must occur in some bag in . However, the nodes representing and must occur together in some bag (as they are the endpoints of arc ), so by Definition ? the node representing must occur in the bag itself. From this, it is easy to see that as has at most elements, configurations at must represent triangulations with at most boundary faces. Therefore by Lemma ? and Definition ? the number of configurations is bounded by some computable function of .

We now calculate the running time of each step in the algorithm. The tree decomposition has nodes, and at each node we go through all three steps. For these steps we do not calculate exact upper bounds, as the functions tend to be exponential or worse. We instead only show that the running time is bounded by some function of , which suffices to give the required result. For these steps, , and are used to denote some arbitrary computable functions of . They are not the same as those given in Definition ?.

At Step ?, we are combining configurations. The number of configurations in each child bag is independent of by the above argument, and each bag has at two children so for a single bag, Step ? takes time per bag.

Step ? takes each such configuration, and at Step ? extends the configuration. Since each bag contains at most elements, Step ? runs at most times per bag. We know that is 4-regular, so by Lemma ? and Definition ? there are at most four distinct pairs of faces to identify, and thus Step ? runs in time and therefore Step ? likewise runs in time. Step ? is simply storing configurations. By condition ? of Definition ?, and the definition of boundary configurations, the size of each configuration is independent of . Since the number of configurations at each bag is also independent of , Step ? can therefore be completed for each bag in time.

Combining the above counts for each step for each of the bags in the tree decomposition gives the required result.

## 5Implementation and experimentation

The algorithm was implemented Java, using the treewidth library from [27]. Although our theoretical bound on the number of configurations is extremely large (Lemma ?), we store all configurations using hash maps to exploit situations where in practice the number of viable configurations is much smaller. As seen below, we find that such a discrepancy does indeed arise (and significantly so).

We also introduce another modification that yields significant speed improvements in practice. The algorithm builds up a complete list of all viable configurations at each bag of the tree decomposition. However, for an affirmative answer to the problem, only a small subset of these may be required. We take advantage of this as follows.

For any bag with no children, configurations are computed as normal. Once a viable configuration is found, it is immediately propagated up the tree in a depth-first manner. This means that, rather than calculating every possible viable configuration for every subgraph , the improved algorithm can identify a full triangulation with property quickly and allow early termination.

We implemented the program with defined to be *one-vertex and possibly minimal*, using criteria on the degrees of edges from [6]. This allowed us to compare both correctness and timing with the existing software *Regina* [9]. We ran our algorithm on all 4-regular graphs on 4, 5 or 6 nodes (see Table ?) to verify correctness. We see that the average time to process a graph increases with treewidth, as expected. We also see that the number of viable configurations is indeed significantly lower than the upper bound of Lemma ?, as we had hoped.

# of graphs | Avg. run time (ms) | maxconfigurations | ||
---|---|---|---|---|

4 | 1 | 1 | 680 | 2 |

4 | 2 | 8 | 4036 | 7 |

4 | 3 | 1 | 13280 | 17 |

5 | 1 | 1 | 780 | 17 |

5 | 2 | 22 | 13446 | 156 |

5 | 3 | 4 | 29505 | 307 |

5 | 4 | 1 | 94060 | 39 |

6 | 1 | 1 | 890 | 17 |

6 | 2 | 68 | 64650 | 1583 |

6 | 3 | 25 | 346028 | 5471 |

6 | 4 | 3 | 297183 | 1266 |

*Regina* significantly outperforms our algorithm on all of these graphs, though these are small problems for which asymptotic behaviour plays a less important role. What matters more is performance on larger graphs, where existing software begins to break down.

We therefore ran a sample of 12-node graphs through our algorithm, selected randomly from graphs which cause significant slowdown in existing software. This “biased” sampling was deliberate—our aim is not for our algorithm to *always* outperform existing software, but instead to seek new ways of solving those difficult cases that existing software cannot handle. Here we do find success: our algorithm was at times 600% faster at identifying non-admissible graphs than *Regina*, though this improvement was not consistent across all trials. More detailed experiments will appear in the full version of this paper.

In summary: for larger problems, our proof-of-concept code already exhibits far superior performance for some cases that *Regina* struggles with. With more careful optimisation (e.g., for dealing with combinatorial isomorphism), we believe that this algorithm would be an important tool that complements existing software for topological enumeration.

The full source code for the implementation of this algorithm is available at http://www.github.com/WPettersson/AdmissibleFPG.

## 6Applications and extensions

We first note that our meta-theorem is useful: here we list several simple properties that are important in practice, with a brief motivation for each.

One-vertex triangulations

are crucial for computation: they typically use very few tetrahedra, and have desirable combinatorial properties. This is especially evident with 0-efficient triangulations [19].

Likewise,

*minimal triangulations*(which use the fewest possible tetrahedra) are important for both combinatorics and computation [6]. Although minimality is not a simple property, it has many simple necessary conditions, which are used in practical enumeration software [7].Ideal triangulation of hyperbolic manifolds

play a key role in 3-manifold topology. An extension of Theorem ? allows us to support several necessary conditions for hyperbolicity, which again are used in real software [12].

Finally: a major limitation of all existing 3-manifold enumeration algorithms is that they cannot “piggyback” on prior results for fewer tetrahedra, a technique that has been remarkably successful in other areas such as graph enumeration [24]. This is not a simple oversight: it is well known that we cannot build all “larger” 3-manifold triangulations from smaller 3-manifold triangulations. The techniques presented here, however, may allow us to overcome this issue—we can modify the algorithm of Theorem ? to store entire families of triangulations at each bag of the tree decomposition. We would lose fixed parameter tractability, but for the first time we would be able to cache and reuse partial results across different graphs and even different numbers of tetrahedra, offering a real potential to extend census data well beyond its current limitations.

### References

- Stefan Arnborg,
*Efficient algorithms for combinatorial problems on graphs with bounded decomposability—a survey*, BIT**25**(1985), no. 1, 2–23. MR 785803 (86k:68038) - Stefan Arnborg, Jens Lagergren, and Detlef Seese,
*Easy problems for tree-decomposable graphs*, J. Algorithms**12**(1991), no. 2, 308–340. MR 1105479 (92d:05150) - Daniel Berend and Tamir Tassa,
*Improved bounds on Bell numbers and on moments of sums of random variables*, Probab. Math. Statist.**30**(2010), no. 2, 185–205. MR 2792580 (2012k:60058) - Hans L. Bodlaender,
*A linear-time algorithm for finding tree-decompositions of small treewidth*, SIAM J. Comput.**25**(1996), no. 6, 1305–1317. MR 1417901 (97m:68160) - Hans L. Bodlaender and Ton Kloks,
*Efficient and constructive algorithms for the pathwidth and treewidth of graphs*, J. Algorithms**21**(1996), no. 2, 358–402. MR 1405685 (98g:68122) - Benjamin A. Burton,
*Face pairing graphs and 3-manifold enumeration*, J. Knot Theory Ramifications**13**(2004), no. 8, 1057–1101. MR 2108649 (2005h:57003) - to3em,
*Enumeration of non-orientable 3-manifolds using face-pairing graphs and union-find*, Discrete & Computational Geometry**38**(2007), no. 3, 527–571. - to3em,
*The cusped hyperbolic census is complete*, in preparation (2014). - Benjamin A. Burton, Ryan Budney, and William Pettersson,
*Regina: Software for 3-manifold topology and normal surface theory.*, 1999-2013. - Benjamin A. Burton, Thomas Lewiner, João Paixão, and Jonathan Spreer,
*Parameterized complexity of discrete Morse theory*, SCG ’13: Proceedings of the 29th Annual Symposium on Computational Geometry, ACM, 2013, pp. 127–136. - Benjamin A. Burton and Jonathan Spreer,
*The complexity of detecting taut angle structures on triangulations*, (2012), SODA ’13: Proceedings of the Twenty-Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, SIAM, 2013, pp. 168-183. - Patrick J. Callahan, Martin V. Hildebrand, and Jeffrey R. Weeks,
*A census of cusped hyperbolic -manifolds*, Math. Comp.**68**(1999), no. 225, 321–332, With microfiche supplement. MR 1620219 (99c:57035) - B. Courcelle, J. A. Makowsky, and U. Rotics,
*On the fixed parameter complexity of graph enumeration problems definable in monadic second-order logic*, Discrete Appl. Math.**108**(2001), no. 1-2, 23–52, International Workshop on Graph-Theoretic Concepts in Computer Science (Smolenice Castle, 1998). MR 1804711 (2002b:05078) - Bruno Courcelle,
*The monadic second-order logic of graphs. I. Recognizable sets of finite graphs*, Inform. and Comput.**85**(1990), no. 1, 12–75. MR 1042649 (91g:05107) - R. G. Downey and M. R. Fellows,
*Parameterized complexity*, Monographs in Computer Science, Springer-Verlag, New York, 1999. MR 1656112 (2001b:68042) - Nathan M. Dunfield and William P. Thurston,
*Finite covers of random 3-manifolds*, Invent. Math.**166**(2006), no. 3, 457–521. MR 2257389 (2007f:57039) - Martin Hildebrand and Jeffrey Weeks,
*A computer generated census of cusped hyperbolic -manifolds*, Computers and mathematics (Cambridge, MA, 1989), Springer, New York, 1989, pp. 53–59. MR 1005959 (90f:57043) - William Jaco, David Letscher, and J. Hyam Rubinstein,
*Algorithms for essential surfaces in 3-manifolds*, Topology and geometry: commemorating SISTAG, Contemp. Math., vol. 314, Amer. Math. Soc., Providence, RI, 2002, pp. 107–124. MR 1941626 (2003m:57043) - William Jaco and J. Hyam Rubinstein,
*-efficient triangulations of 3-manifolds*, J. Differential Geom.**65**(2003), no. 1, 61–168. MR 2057531 (2005d:57034) - Ton Kloks,
*Treewidth*, Lecture Notes in Computer Science, vol. 842, Springer-Verlag, Berlin, 1994, Computations and approximations. MR 1312164 (96d:05038) - Bruno. Martelli and Carlo. Petronio,
*Three-manifolds having complexity at most 9*, Experimental Mathematics**10**(2001), no. 2, 207–236. - Sergei Matveev,
*Algorithmic topology and classification of 3-manifolds*, second ed., Algorithms and Computation in Mathematics, vol. 9, Springer, Berlin, 2007. MR 2341532 (2008e:57021) - Sergei V. Matveev,
*Computer recognition of three-manifolds*, Experiment. Math.**7**(1998), no. 2, 153–161. MR 1677162 (2000b:57033) - Brendan D. McKay,
*Isomorph-free exhaustive generation*, J. Algorithms**26**(1998), no. 2, 306–324. - Neil Robertson and P. D. Seymour,
*Graph minors. II. Algorithmic aspects of tree-width*, J. Algorithms**7**(1986), no. 3, 309–322. MR 855559 (88c:05053) - Morwen Thistlethwaite,
*Cusped hyperbolic manifolds with 8 tetrahedra*,`http://www.math.utk. edu/~morwen/8tet/`

, October 2010. - Thomas van Dijk, Jan-Pieter van den Heuvel, and Wouter Slob,
*Computing treewidth with LibTW*, (2006).