Ahoy there, sailor!
You’ve been away on a long voyage across the four-dimensional sea. Its heaving surface isn’t a sheet of water but a whole volume of it, slamming into your hull from directions no 3D sailor has a name for. The horizon all around you is a sphere rather than a circle. As well as fore and aft, port and starboard, and up and down, there’s a fourth axis, and your boat can steer along it. Charles Hinton, who spent the 1880s trying to teach people to picture four dimensions, named its two directions ana and kata, and they’ve served 4D sailors ever since.
Now the harbour wall is coming up off your ana bow, and it’s time to moor.
You throw a line around the bollard, tie a bowline and step ashore. Behind you, the knot slides open: one strand steps ana, slips past another, and the bowline falls apart.
A knot holds in three dimensions because rope can’t pass through rope. Draw a knot flat and at every crossing one strand goes over the other. To swap which strand is on top, the upper strand would have to drop past the lower one right where they cross, and there the two would meet. Solid rope can’t do that.
In four dimensions there’s a way around. Give every point of the sea four coordinates, \((x, y, z, w)\). The first three are the usual ones, and \(w\) measures how far a point is ana (\(w > 0\)) or kata (\(w < 0\)). Mathematicians call this space \(\mathbb{R}^4\).
Lift a short piece of the upper strand ana. It’s now at a different \(w\) from the lower strand, so the two can share the same \((x, y, z)\) without touching. Lower it past the lower strand, bring it back kata, and the crossing has changed without the strands ever meeting.
In the figures, colour is \(w\): blue is kata, cream is \(w = 0\) and orange is ana. Two pieces of rope touch only if they’re in the same place and the same colour.
That’s enough to untie any knot. Pick a starting point on a knot diagram, away from any crossing, and walk once around the diagram. At every crossing you reach for the first time, make your strand the upper one. When you reach a crossing for the second time you’re on the lower strand, so leave it as it is.
The new diagram is always the unknot. To see why, give the rope heights that match it. Start at height 1 and let the height fall steadily as you walk, down to 0 as you arrive back at the start, then climb straight up to height 1 there. At every crossing the strand you reached first is higher, just as the diagram says. For each height \(h\) between 0 and 1, the rope now has exactly two points at that height, one on the way down and one on the climb. Join them with a horizontal segment. Segments at different heights lie in different horizontal planes, so none of them meet, and together they fill in a disc whose edge is the rope. Shrinking the rope across that disc turns it into a small circle, so it was the unknot all along.
So every knot turns into the unknot after some crossing changes, and in \(\mathbb{R}^4\) every crossing change is free.
That covers rope lying in ordinary space. A rope anywhere in \(\mathbb{R}^4\) can be moved there first, by shrinking every point’s \(w\) to 0. Two points of the rope would only collide on the way if they had the same \(x\), \(y\) and \(z\), and a slight nudge to the rope beforehand removes any such pairs. So in \(\mathbb{R}^4\), every knot comes undone.
The general idea is codimension, the dimension of the space minus the dimension of the object in it. A rope is 1D. In ordinary space it has codimension 2, which is enough room to go around another strand but not enough to get past it. In \(\mathbb{R}^4\) it has codimension 3, and the spare dimension lets every crossing undo itself.
No knots, then. But a rope doesn’t need a knot to hold. Pass it around a bollard and fuse the ends into a closed loop, and there’s nothing left to untie. You try it on the nearest bollard, and the loop slips off ana. The harbourmaster has watched plenty of visiting sailors do this, and points you down the quay to a different kind of bollard.
To see why the first one failed, start with an ordinary post in three dimensions, and for now assume it goes up forever. A real post has a top you could lift the loop over, and section 4 comes back to that.
Whether the post holds the loop comes down to a count. Stretch a surface across the loop, such as a soap film, and give it a front and a back. Follow the post upward, adding 1 each time it passes through the film from back to front and subtracting 1 each time it passes from front to back. The total is the linking number of the loop and the post. A loop dropped over the post has linking number \(\pm 1\). A loop lying on the quay beside the post has linking number 0.
Two facts make this count useful. First, it doesn’t depend on which film you choose. Two films with the same edge together form a closed surface, and a line running off to infinity at both ends leaves a closed surface as often as it enters. Second, it can’t change while the rope moves without touching the post. Carry the film along with the rope. Crossings in the film’s interior appear and disappear only in pairs of opposite sign, as the post slides over a fold in the film, so they leave the total unchanged. A single crossing can only escape across the film’s edge, and the edge is the rope itself. So no motion takes the loop from around the post to the quay beside it, and the post holds the rope.
The count needs the film and the post to cross at isolated points. In \(\mathbb{R}^n\), an \(a\)-dimensional object and a \(b\)-dimensional one in general position cross at isolated points when \(a + b = n\), and miss each other entirely when \(a + b < n\). In 3D the film is 2D and the post is 1D, and \(2 + 1 = 3\).
In 4D the film is still 2D and a line is still 1D, but now \(2 + 1 < 4\). Nudge the post ana and it misses the film altogether. The rope can then shrink across the film to a tiny loop without touching the post, and float away. To hold the rope, the bollard has to cross the film at isolated points, so it has to be 2D: \(2 + 2 = 4\). In \(\mathbb{R}^4\), a rope loop can only be held by a two-dimensional bollard.
The same count works in any dimension. A \(p\)-sphere is the \(p\)-dimensional version of a circle. A loop of rope is a 1-sphere, and a closed sheet with no holes, like a balloon, is a 2-sphere. A \(p\)-sphere bounds a \((p + 1)\)-dimensional film, so it can be linked with a \(q\)-dimensional object in \(\mathbb{R}^n\) when \((p + 1) + q = n\), or
\[p + q = n - 1.\]A loop of string on a table links a point (\(1 + 0 = 2 - 1\)), a rope in ordinary space links a line (\(1 + 1 = 3 - 1\)), and a rope in \(\mathbb{R}^4\) links a plane (\(1 + 2 = 4 - 1\)).
Real bollards are solid, though. What counts is a bollard’s core, what’s left if you shrink it without it ever touching the rope. An ordinary post shrinks to the line up its middle. The rope never touches the post as it shrinks, so the linking number doesn’t change, and the line holds the rope just as the post did. So \(q\) is the dimension of the core.
The bollard you tried was the obvious 4D version of a post. A 4D sea has three horizontal directions, \(x\), \(y\) and \(w\), and that bollard was round in all three and ran up in \(z\). Its exact shape doesn’t matter, though. Any bollard that’s only so wide in each of \(x\), \(y\) and \(w\) shrinks to a line, and a line can’t hold a rope in \(\mathbb{R}^4\). The harbourmaster’s bollard is different. It’s round only in \(x\) and \(y\), and it runs up in \(z\) and keeps going ana and kata in \(w\), forever in both, so its core is the \(zw\)-plane.
The easiest way to see the difference is to look at the harbour one slice at a time. The slice at a fixed \(w\) is an ordinary 3D space, and moving the slice ana and kata shows how things change along the fourth axis.
The round bollard gets thinner as you move ana, the same way the slices of a ball shrink towards its edge, and then it stops. Beyond its edge the slices are just water. So the rope steps ana past the bollard’s edge, slides sideways, and comes back kata beside it. The long bollard is in every slice, so wherever the rope goes, the bollard is still inside it.
At the long bollard, the harbourmaster brings a coil of rope from the ropewalk, runs it around the bollard and around a cleat of the same long shape on your deck, and splices the ends together where they lie. The splice is necessary. The count that stops a closed loop coming off also stops one going on, so the only way to get a closed loop around the bollard is to close it in place. Your boat is moored without a single knot.
The boat is safe, but every knot you know is now useless. You can’t lash a crate, hitch a fender or tie off a sail. The harbourmaster sees you turning a length of rope over in your hands and passes you a tarpaulin. “If it’s knots you want, give up on rope.”
Go back to the codimension count from section 1. A rope has too much room in \(\mathbb{R}^4\). A sheet has less. A tarpaulin is 2D, so in \(\mathbb{R}^4\) its codimension is 2, the same as rope in ordinary space. Closed sheets in \(\mathbb{R}^4\) can be knotted. From here on a closed sheet means a 2-sphere, as in section 2.
The move that undid the bowline doesn’t work on a sheet. Lifting one patch of sheet past another needs a spare dimension, and a sheet in \(\mathbb{R}^4\) has none. That doesn’t prove any sheet is knotted, since some other motion might still undo it. A proof needs an invariant, a quantity that stays the same however the sheet moves without passing through itself, and that differs between the sheet in question and a plain sphere.
The first knotted surface was built by Emil Artin in 1925, by spinning. It takes three steps to see how.
Spinning in 3D. Hold a semicircle with both ends on a vertical axis and spin it about the axis. Each point of the arc travels around a circle, bigger the further it is from the axis, and the two ends stay where they are. The arc sweeps out a sphere.
Turning in 4D. In 3D, a rotation turns about a line: points on the axis stay put and every other point moves in a circle. In 4D, a rotation turns about a whole plane. A rotation that mixes \(x\) and \(w\) leaves every point with \(x = w = 0\) where it is, which is the \(yz\)-plane, and moves every other point in a circle. A point that starts in ordinary space at distance \(d\) from the plane swings out ana, is at \(x = 0\) and \(w = d\) after a quarter turn, and arrives back in ordinary space on the far side of the plane after half a turn. The second half of the turn brings it back through kata.
Spinning a knotted arc. Take a knotted arc in ordinary space with both ends on the plane \(x = 0\) and the rest of it on the side \(x > 0\), and turn it through \(w\) about that plane. Just like the semicircle, each point sweeps out a circle and the ends stay put, so the arc sweeps out a sphere. The sphere contains a copy of the knotted arc at every angle of the turn.
Artin’s invariant was the fundamental group of the space around the sphere, the group of loops in that space up to continuous deformation. He showed that the spun sphere’s group is the same as the group of the space around the original knot in \(\mathbb{R}^3\). For the trefoil that group isn’t commutative. Around an unknotted sphere it’s the integers, so the spun trefoil can’t be unknotted. Rolfsen’s textbook Knots and Links (1976) covers spinning along with other knotted surfaces.
You can also look at the knotted sphere the way you looked at the bollards, one slice at a time.
At \(w = 0\) the slice is the knotted arc joined end to end with its own mirror image. For the trefoil that’s a right-handed trefoil joined to a left-handed one. Knot theorists call it the square knot, a name borrowed from the reef knot (the square knot in America), whose drawing it resembles. Move ana or kata and the parts of the arc nearest the plane drop out of the slice. The knot breaks into separate loops, and they shrink and vanish at the sphere’s edge. The slices at \(w\) and \(-w\) have the same shape, because the turn is symmetric.
A tarpaulin also rescues the round bollard the rope slipped off. For a sheet, \(p = 2\), so the rule gives \(2 + q = 3\) and \(q = 1\): a closed sheet is held by a bollard whose core is a line.
It’s easiest to see at a single height. In the 3D slice at a fixed height \(z\), the round bollard is a solid ball. A rope loop around a ball just slides off it, but a sheet can wrap the ball completely. Shrink the ball to its core and you have the \(\mathbb{R}^3\) case of the rule, \(2 + 0 = 3 - 1\), a closed sheet held by a point. In ordinary space that’s a balloon with a speck of dust inside. Nobody would call it mooring, but it meets the definition used all along, since the two can’t be separated without one passing through the other. Here the point is one slice of the bollard’s core, which carries on up and down, so the sheet can’t slip off in \(z\) either.
So gather the tarpaulin around the bollard like a sack and fuse the neck shut, the way the harbourmaster spliced the rope. Don’t knot the neck. Gathered up, it’s a thin strand of sheet, and a thin strand tied like rope slips ana just as the bowline did.
Here is everything in one table. A \(p\)-sphere in \(\mathbb{R}^n\) is held by a core of dimension \(n - 1 - p\). In the table, knots hold only where the codimension is 2.
| A rope loop is held by a core that is | A closed sheet is held by a core that is | Knots in rope loops | Knots in closed sheets | |
|---|---|---|---|---|
| \(\mathbb{R}^3\) | a line | a point | hold | don’t |
| \(\mathbb{R}^4\) | a plane | a line | don’t | hold |
One entry hasn’t come up yet. A sheet in \(\mathbb{R}^3\) has codimension 1, and J. W. Alexander proved in 1924 that every smooth 2-sphere in \(\mathbb{R}^3\) bounds a solid ball, so it can be shrunk to a point and can’t be knotted. The table needs the restriction to spheres. A torus can be knotted in \(\mathbb{R}^3\), as the skin of a thickened trefoil.
Codimension 2 isn’t the only place knots can hold, though. In 1962 André Haefliger found smooth 3-spheres in \(\mathbb{R}^6\) that are knotted, in codimension 3.
Two assumptions did a lot of work. First, “held” meant held by topology alone. Real rope also depends on friction and stiffness, and a 4D rope would be a tube thick in three directions, whose mechanics nothing here describes. Second, every bollard went on forever. That’s the same fact as the splice. The count that stops a loop coming off also stops it going on, so the rope had to be spliced around the bollard and the sack closed around it. A real bollard has a top, and a flared top, the sideways pull of the boat and friction keep the rope on. A real 4D bollard would need the same, flaring out ana and kata as well as up, since the long bollard can’t go on forever in \(w\) either.
Knotted surfaces in four dimensions are still an active area of research.
Fair winds, sailor, and keep a tarpaulin aboard. Next time you’re in, ask the harbourmaster about chains.
ES-HyperNEAT (Risi & Stanley, 2012) decides where to put hidden neurons by evaluating its CPPN at the \(2^n\) sub-cells of every cell it looks at. That’s why its search slows down exponentially as the substrate gains dimensions. But to first order those \(2^n\) samples only measure one thing, the squared gradient of the weight field, and a gradient costs one forward and one backward pass whatever the dimension.
So I swapped the test. The gradient version made the same split decision as sampling 98.7% of the time, and found equally good networks in about a sixth of the search time on a 3D substrate. A smarter sampler closes some of that gap, and the tree itself still grows exponentially.
Epistemic status: the equivalence is derived and checked numerically. The training comparison is 8 paired runs on one toy task, which is enough to rule out big differences in performance but not small ones.
Part 1 introduced ES-HyperNEAT and the steering task used here. The short version: HyperNEAT computes each weight from the coordinates of the two neurons it connects, \(w = f(\mathbf{p}, \mathbf{q})\), using a small network called the CPPN, and ES-HyperNEAT puts hidden neurons wherever \(f\) varies, finding those places with a quadtree.
Part 1 found that matching the substrate’s dimension to the problem helps, and that each extra dimension multiplies the cost of that quadtree search.
The quadtree splits a cell when the CPPN’s weights at its \(2^n\) sub-cell centres vary by more than a threshold \(\tau\). Variance across a small cell is a measure of how fast the weight field changes there, which is what a gradient tells you.
Take a cell centred at \(c\) with half-width \(r\). Its sub-cell centres are \(c + \tfrac{r}{2}\sigma\), where \(\sigma\) runs over every pattern of \(\pm 1\) signs. Near \(c\) the field is roughly linear:
\[w\!\left(c + \tfrac{r}{2}\sigma\right) \approx w(c) + \tfrac{r}{2}\, \sigma \cdot \nabla w(c)\]Over the \(2^n\) sign patterns each \(\sigma_i\) is \(+1\) half the time and \(-1\) half the time, independently of the others, so \(\mathbb{E}[\sigma_i] = 0\), \(\mathbb{E}[\sigma_i^2] = 1\) and \(\mathbb{E}[\sigma_i \sigma_j] = 0\) for \(i \neq j\). The constant \(w(c)\) drops out of the variance, which leaves
\[\operatorname{Var}_{\text{sub-cells}}(w) \;\approx\; \left(\tfrac{r}{2}\right)^{2} \sum_{i=1}^{n} \left(\frac{\partial w}{\partial x_i}\right)^{2} \;=\; \left(\tfrac{r}{2}\right)^{2} \lVert \nabla w(c) \rVert^{2}\]So the tree, the threshold and everything else can stay as they are. Only one line changes:
\[\text{split if } \operatorname{Var}(2^n \text{ samples}) > \tau \quad\longrightarrow\quad \text{split if } \left(\tfrac{r}{2}\right)^{2}\lVert \nabla w(c)\rVert^{2} > \tau\]Numerically it holds up well. On random CPPNs the gradient’s estimate is within 5–15% of the sampled variance on the biggest cells, and indistinguishable from it on small ones.
The gradient is cheap because of reverse-mode automatic differentiation (backpropagation). It gets all \(n\) partial derivatives in one backward pass, for a small constant multiple of the forward cost, however big \(n\) is. The chain rule works back from the single output and reuses each intermediate value from the forward pass once, so a test costs one forward and one backward pass instead of \(2^n\) forward passes.
The tree itself doesn’t change, though. A cell the gradient marks as varying still splits into \(2^n\) new cells, so each test gets roughly \(2^n/2\) times cheaper while all \((2^n)^m\) cells are still there.
The approximation breaks when the field is far from linear across a cell. A saddle centred exactly on a cell has zero gradient at the one point the test looks at, so the gradient test thinks the cell is flat and never splits it; the Blind spot button below builds one. Sampling has its own blind spots. A bump centred on a cell gives four identical samples.
Compare outlines the cells where the two tests disagree.
How often does this matter in practice? We rebuilt trees for random CPPNs in 2 to 7 dimensions and scored every cell with both tests. They agreed on 98.7% of 2,580 split decisions. In 32 of the 34 disagreements the gradient split a cell that sampling left alone, and only 2 went the other way.
That lean matches section 1: on big cells the gradient’s estimate runs a little high, which tips borderline cells over the threshold. An extra split costs a bit of compute. A missed split loses detail, and those were rare.
Against sampling as published, the gradient test needs 2× fewer CPPN passes in 2D and 61× fewer in 7D, and the search time follows the same curve.
One depth-2 tree, median over 10 random CPPNs with 4 inputs and 4 outputs. A backward pass counts as one pass; the corner-cache sampler is counted, not run.
| n | sampling | corner cache | gradient | time: sampling | time: gradient |
|---|---|---|---|---|---|
| 2 | 416 | 144 | 208 | 1.1 ms | 0.75 ms |
| 3 | 3,136 | 784 | 784 | 3.9 ms | 1.2 ms |
| 4 | 24,704 | 4,096 | 3,344 | 27 ms | 2.9 ms |
| 5 | 24,832 | 4,540 | 2,576 | 27 ms | 2.4 ms |
| 6 | 786,944 | 67,112 | 27,152 | 873 ms | 24 ms |
| 7 | 6,358,016 | 275,476 | 103,440 | 8.8 s | 0.10 s |
It isn’t quite a fair fight, though. The published algorithm samples sub-cell centres, and none of those samples ever get reused. A variant that samples cell corners instead, and caches them, can reuse each corner in every cell that touches it. On the same trees that makes sampling 3× cheaper in 2D and 16× cheaper in 7D.
Against that version the gradient test is actually more expensive in 2D, level in 3D, and only 2.7× cheaper in 7D. Both still climb steeply, because both still build a \(2^n\)-way tree.
Last, back to part 1’s steering task, on both the 3D substrate and the 2D map projection. The two versions share every line of code except the split test: same tree, thresholds, network, task, evolutionary algorithm and settings. They also share random seeds, so each gradient run starts from the same CPPN and gets the same random perturbations as its sampling twin. The two only drift apart once the tests first disagree about a split.
Top: mean ±1 standard error over 8 paired runs. Bottom: each seed; a dot inside its ring means both tests did equally well.
| 3D sampling | 3D gradient | 2D sampling | 2D gradient | |
|---|---|---|---|---|
| mean final score (8 runs) | 0.737 | 0.728 | 0.551 | 0.570 |
| runs reaching 0.68 | 8 / 8 | 7 / 8 | 4 / 8 | 4 / 8 |
| neuron-placement time per genome | 79 ms | 14 ms | 11.5 ms | 5.0 ms |
| one full training run | 5.9 min | 1.7 min | 1.2 min | 0.7 min |
Timings on an AMD Ryzen 7 7840HS, 15 runs in parallel. A genome is one candidate CPPN.
Performance came out the same. In 3D the mean final scores differ by less than 0.01, slightly in sampling’s favour (95% confidence interval for the difference: −0.027 to +0.002), and each version won four of the eight pairs. Most of that gap is one gradient run that was still improving when training stopped.
In 2D the gradient version is slightly ahead on average (95% confidence interval: −0.042 to +0.089), but it only won three of the eight pairs, with one tie. Its lead comes from two big wins. The 2D runs that succeeded were the same four seeds under both tests, so a run’s outcome is set by its starting CPPN and the substrate, not by the split test.
All 8 runs of each version, one per chase. Sampling and gradient panels always show the same seed.
Where they differ is time. Placing neurons took about a sixth as long in 3D and under half as long in 2D, so a full 3D training run finished 3.5× sooner. Going from 2D to 3D multiplied sampling’s placement cost by 7 and the gradient’s by 3, because sampling pays for both the bigger tree and the doubled cost of each test, while the gradient only pays for the bigger tree.
This is a simplified ES-HyperNEAT written from scratch, with a fixed-shape CPPN trained by an evolution strategy instead of NEAT. Both versions share all of it, so the comparison is fair, but the absolute numbers would come out differently in the reference implementation.
It’s one toy task with 8 paired runs per substrate, which rules out big differences but not small ones. Part 1 describes the fixes that were needed before anything learned at all. Code and raw results are in /experiments/es-hyperneat/, and the two versions differ only in the function complexity() in eshn.py.
Swapping the quadtree’s \(2^n\) samples for one gradient leaves the split decisions, and the networks that come out of them, almost unchanged, and it takes the exponential cost out of each test. The tree still branches \(2^n\) ways, so higher dimensions aren’t free. But 5, 6 and 7-dimensional substrates are now cheap enough to try, which raises the question of what a 5-dimensional task actually looks like.
In a life simulation, more of them than you might expect. A cell that senses which way the food is lives in 3D, but one that also cares which way it’s facing has three more axes, for six. A member of a swarm reacting to its neighbours’ positions and velocities lives in the same six. A creature that grows adds time to its 3D body, and a cellular automaton whose cells carry several chemical signals gets an axis for each one on top of its grid.
Outside artificial life it’s the same story. A drone’s controls depend on both its position and its orientation. A robot arm’s state lives in the six or seven dimensions of its joint angles. Medical scans are 3D volumes that change over time, and so is the weather. Whenever a task’s inputs and outputs come with a natural geometry of more than three dimensions, a substrate that matches it might make the right network simple, the way the 3D substrate did for the swimming cell.
Finding out no longer gets exponentially more expensive with every dimension, and I’d love to see what turns up.
]]>Artificial life simulations are full of small creatures that need brains: cells chasing food, swimmers, walkers, whole ecosystems of them. Those brains are usually evolved, and one of the nicest ways to do it came out of the field itself: ES-HyperNEAT (Risi & Stanley, 2012).
ES-HyperNEAT doesn’t evolve a network’s weights one by one. It evolves a small function that draws them from geometry. Each neuron gets coordinates, and the weight between two neurons is that function evaluated at their two positions, so moving a neuron changes all of its weights, and with them what it computes. That lets a creature’s brain mirror the layout of its body, and the same function decides where the hidden neurons go.
The same family of encodings has since evolved cellular automata that grow and copy patterns (Nichele et al., 2017), and whole ecosystems of neural cellular automata (Barbieux & Canaan, 2024).
ES-HyperNEAT’s brains are usually flat, though. Its search is a quadtree, built for a 2D sheet, while plenty of simulated creatures live in 3D. What I wanted to know is whether that matters. The test is a single cell chasing a drifting bit of food in 3D.
With the neurons laid out in 3D, the one-line rule “connect neurons that are close” steers about as well as a hand-built controller. Flatten the same neurons onto a plane and the rule falls apart in every layout I tried. In one of them the up and down thrusters end up on the same spot and cancel each other out, so the cell can never change height.
Evolving from scratch tells a similar story. ES-HyperNEAT found a good controller in every 3D run, and in about half the runs on the best 2D layout.
Every evolved run, one per chase. 3D always catches the food, the 2D map about half the time, and drop z can't change height.
The problem is cost. The search that places hidden neurons gets exponentially more expensive with every dimension you add, and Part 2 is about making it cheaper.
Epistemic status: one toy task, 8 seeds per setup, and a simplified ES-HyperNEAT written from scratch rather than the reference code. The hand-set rule result is big and clear. The evolution result is suggestive, with one open confound: the 3D networks grew about six times as many hidden neurons.
HyperNEAT puts every neuron at a point in a geometric space, called the substrate, and computes each weight from the positions of the two neurons it connects:
\[w = f(\mathbf{p}, \mathbf{q})\]The function \(f\) is itself a small network, the CPPN (compositional pattern-producing network). Evolution never touches the weights directly. It evolves \(f\), originally with NEAT.
Because \(f\) is smooth, neurons that sit near each other get similar weights. And since \(f\) only ever sees coordinates, a rule like “connect neurons that are close” needs nothing more than the distance \(\lVert \mathbf{p} - \mathbf{q} \rVert\). (HyperNEAT is usually sold on symmetry and repetition. This post leans on something plainer, locality.)
So where do the coordinates come from? The designer places the input and output neurons to match the physical layout. A sensor that looks left goes on the left of the substrate, and a thruster that pushes up goes near the top. That’s the only place the physical world gets into the network.
Hidden neurons don’t correspond to anything physical. What matters is what they’re near. A hidden neuron’s weights are the CPPN evaluated between its position and each input and output, so under “connect what’s close”, one sitting between the left sensor and the left thruster mostly listens to the first and drives the second. Its position is its job.
ES-HyperNEAT (Risi & Stanley, 2012) goes a step further and lets \(f\) place the hidden neurons too. Only the inputs and outputs are fixed. Pin one end of a connection to an input neuron, say at \((0, -1)\), and \(f(0, -1, x, y)\) becomes a scalar field over the substrate: the weight a hidden neuron at \((x, y)\) would get from that input.
Hidden neurons go where this field varies. Where it’s flat, neighbouring neurons would get identical weights and compute the same thing, so extra ones would be wasted.
To find those regions, ES-HyperNEAT keeps splitting the square into quarters:
The explorer below runs this on the field of a random CPPN, \(w(x, y) = f(0, -1, x, y)\). Colour is the weight, lines are the leaf cells and dots are hidden neurons. Drag \(\tau\) down and the tree digs into the busy regions.
Since the CPPN only sees coordinates, a substrate works well when its coordinates capture the geometry the task cares about. The weights you need are then a simple function of position, and simple functions are what evolution tends to find first, because it builds up a CPPN one mutation at a time.
The test task is deliberately 3D. A point agent (the cell above) chases a target (the food) along a random 3D curve. It has 14 sensors pointing in fixed directions \(\mathbf{u}_k\), the 6 faces and 8 corners of a cube, and sensor \(k\) reads \(s_k = \max(0, \mathbf{u}_k \cdot \hat{\mathbf{r}})\), where \(\hat{\mathbf{r}}\) points at the target. It steers with 6 thrusters, along \(\pm x\), \(\pm y\) and \(\pm z\), through a network with one hidden layer.
A hand-built controller that just thrusts towards the target scores 0.730. Zero thrust scores 0.225.
That controller is purely geometric. If a sensor fires, the food is roughly in that sensor’s direction, and the thrusters pointing that way will push the cell towards it. So thruster \(j\) should respond to sensor \(k\) in proportion to how well their directions line up, \(\mathbf{u}_k \cdot \mathbf{a}_j\). Put every sensor and thruster on the substrate at its real direction (sensors at radius 1, thrusters at radius 0.5) and “lined up” turns into “close together”, because at fixed radii
\[\lVert \mathbf{p} - \mathbf{q} \rVert^2 = \lVert \mathbf{p} \rVert^2 + \lVert \mathbf{q} \rVert^2 - 2\, \mathbf{p} \cdot \mathbf{q}\]shrinks as \(\mathbf{p} \cdot \mathbf{q}\) grows. So the locality rule
\[w = b - k \lVert \mathbf{p} - \mathbf{q} \rVert\]is the controller, routed through a grid of hidden neurons. Short connections are positive and long ones negative. A sensor excites the hidden neurons near it, and they excite the thrusters near them, which point the same way as the sensor.
A flat substrate can’t do this properly. The Borsuk–Ulam theorem says any continuous flattening of a sphere sends some pair of opposite directions to the same point. With only 14 sensors you can dodge the collision by tilting the projection, but the map still squashes some directions together and pulls others apart. The ring layout avoids collisions by giving up continuity altogether, so neighbours on the ring point in unrelated directions.
Try it below. Pick a substrate and play with \(k\) and \(b\), or hit the search button. The hidden neurons sit on a fixed grid here; in section 4 evolution gets to place them.
Live scores on 16 random chases. The table has the best settings from a grid search.
| Substrate | Best score with \(w = b - k\lVert \mathbf{p} - \mathbf{q} \rVert\) |
|---|---|
| 3D (true directions) | 0.745 |
| 2D, drop z | 0.317 |
| 2D, map projection (azimuthal equidistant) | 0.306 |
| 2D, sensors round a ring | 0.231 |
| reference: zero thrust / hand-built controller | 0.225 / 0.730 |
In 3D the locality rule does as well as the hand-built controller. In every 2D layout it lands much closer to zero thrust. A cleverer CPPN could encode exceptions to locality, but evolution would have to stumble on each one.
The hand-set rule used a fixed grid, though. The real test is letting ES-HyperNEAT do the whole job: evolve the CPPN from a random start and place the hidden neurons with its own quadtree.
python run_all.py reruns everything, and results/ holds each run’s raw output, including its final CPPN.Top: mean test score, ±1 standard error. Bottom: every run's final score.
Every 3D run ended up level with the hand-built controller.
The 2D map projection split down the middle. Four of its eight runs got there too, just later, and the other four stalled somewhere between 0.27 and 0.54. The ring layout never got above 0.35.
The “drop z” layout is my favourite failure. All four runs finished at exactly 0.319. Dropping \(z\) sends the \(\pm z\) directions to the same point, which is exactly where a sensor pair and a thruster pair live. The two vertical thrusters always get identical weights, fire together and cancel, so the cell can’t change height whatever the CPPN does.
There’s one confound I can’t rule out. The 3D networks grew about 480 hidden neurons to 2D’s 75. That isn’t because the 2D tree ran out of room, but it does mean this experiment can’t separate “more dimensions” from “more neurons”.
In \(n\) dimensions the quadtree becomes a \(2^n\)-tree. A cell has 4 sub-cells in 2D, 8 in 3D and 64 in 6D, and both parts of the cost scale with that:
If the field varies everywhere down to depth \(m\), that’s roughly \((2^n)^m\) cells at \(2^n\) evaluations each, for every input neuron.
Here’s what that looks like on random CPPNs in 2 to 7 dimensions, with trees of depth 2:
Median over 10 random CPPNs, log scale. Tree sizes vary, which is why 5D is no dearer than 4D.
| n | cells tested | CPPN evaluations | time per search |
|---|---|---|---|
| 2 | 13 | 416 | 1.1 ms |
| 3 | 49 | 3,136 | 3.9 ms |
| 4 | 193 | 24,704 | 27 ms |
| 5 | 97 | 24,832 | 27 ms |
| 6 | 1,537 | 786,944 | 0.87 s |
| 7 | 6,209 | 6,358,016 | 8.8 s |
Timings from an AMD Ryzen 7 7840HS.
Going from 2D to 7D makes the work about 15,000 times bigger, and that’s one search on one network. Evolution runs a search for every candidate CPPN in every generation. Even in the steering experiment, moving from 2D to 3D stretched a 1.2-minute training run to 5.9 minutes.
Matching the problem’s geometry argues for as many dimensions as the problem has, and most physical problems, from robot arms to drones, are 3D. Every dimension you add multiplies the cost of placing neurons.
There may be a way round it. The quadtree’s variance test is really asking how fast the weight field changes across a cell, which is a question about its gradient, and the CPPN is built from differentiable functions. Part 2: A gradient test for ES-HyperNEAT’s quadtree swaps the \(2^n\) samples for one gradient and checks whether it finds equally good networks for less work.