# Low Dimensional Topology

## May 31, 2013

### The algorithm to recognise the 3-sphere

Filed under: 3-manifolds,Computation and experiment,Triangulations — Ryan Budney @ 10:48 am
Tags: ,
The purpose of this post is to convince you the 3-sphere recognition algorithm is simple.  Not the proof!  Just the statement of the algorithm itself.  I find in conversations with topologists, it’s fairly rare that people know the broad outline of the algorithm.  That’s a shame, because anything this simple should be understood by everyone.

I was starting grad school when the 3-sphere recognition algorithm was announced. There was a semester-long seminar on the topic.  The seminar did not help me much!  Thankfully, the algorithm has become simpler over the past decade — I don’t think I’m any better at understanding things, but Jaco and Rubinstein have done a lot to compactify the algorithm.  If you’ve studied enough 3-manifold theory to know about normal surfaces and the Haken algorithm, you know enough to understand the statement of the 3-sphere recognition algorithm.

The Algorithm

Start with a 3-manifold triangulation TRI.  The three-sphere recognition algorithm has two major steps.

1)  Build a LIST of 3-manifold triangulations, and initialize LIST to contain only TRI.  Inductively, enumerate the normal 2-spheres in the triangulations in LIST. On each normal 2-sphere we perform the crushing operation (collapsing the sphere to a point in the manifold).  This turns your 3-manifold into a wedge sum of other 3-manifolds which have less complex triangulations in the sense of number of tetrahedra (I’ll return to this).  Replace each triangulation from LIST by these wedge summands and repeat this process until none of the 3-manifolds in your LIST contain normal 2-spheres.  Of course, if your manifold was an $S^1 \times S^2$ the crushing operation might have converted it into an $S^3$ with two points identified — but you could have computed the homology beforehand and noticed your manifold wasn’t a homology sphere to begin with. And every 3-manifold has normal 2-spheres, the vertex-linking ones. We ignore those.

2) A 3-manifold triangulation with no normal 2-spheres is the 3-sphere if and only if it contains an almost-normal 2-sphere.  So you just check the manifolds of LIST to ensure they all have almost-normal 2-spheres.  If you’re not familiar with almost-normal surfaces, conceptually the way to think about them is that they are the “intermediate” surfaces one needs if you are interested in the isotopy relation among normal surfaces, or more generally the embedded-surgery relation among normal surfaces. They are also enumerable in terms of integer programming problems, much like normal surfaces.

That’s it.  That’s the algorithm.  You can turn it into an algorithm to find the connect-sum decomposition of a 3-manifold, since that’s essentially what you’re doing.  There are a few qualifiers I’ve neglected to tell you.  The big one is the crushing operation I’ve left vague. That’s because it’s an especially brutal version of crushing that Jaco and Rubinstein use — and it’s brutality is a rather lovely feature.  Below is a picture I’ve stolen from Ben Burton’s recent paper.

When you crush a normal 2-sphere, a tetrahedron can be converted into a variety of things. Ben calls these respectively: tetrahedra, purses and footballs. The crushing operation turns the footballs into edges and purses into triangles, and of course you keep the tetrahedra. So when you crush in this manner you sometimes eliminate summands that are non-trivial manifolds. It turns out the “damage” you can do in this way is quite limited, crushing can eliminate $\mathbb RP^3$, $L_{3,1}$ and $S^1\times S^2$ summands, but that is all — otherwise it faithfully computes the connect sum decomposition.

This version of the 3-sphere recognition algorithm appears Rubinstein and Jaco’s 0-efficiency paper:

Jaco and Rubinstein.  J. Differential Geom. Volume 65, Number 1 (2003), 61-168.

The 3-sphere recognition and connect-sum algorithms are implemented in the software Regina. Here is a link to the code for its implementation. You might find the code easier to read than my blogpost!