Ahoy there, sailor!
You’ve been away on a long voyage across the four-dimensional sea. The horizon all around you is a sphere rather than a circle. The sea’s roiling 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. 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, which is infinitely tall at this particular port, tie a bowline and step ashore. Behind you, the knot slides open. One strand steps ana, slips past the other, and the bowline falls apart.
A knot holds in three dimensions because rope can’t pass through rope. In four dimensions, there’s a way around. Every point in the sea, the sky and the space around you has four coordinates, \((x, y, z, w)\). The first three are the usual ones, but \(w\) measures how far a point is ana (\(w > 0\)) or kata (\(w < 0\)). Mathematicians call this space \(\mathbb{R}^4\).
Exploring your rope, you cross it over itself then lift the upper strand ana. It’s now at a different \(w\) from the lower strand, meaning the two can share an \((x, y, z)\) position without touching. You move it down along \(z\), bring it back kata, and the crossing has changed without the strands ever meeting.
In the diagram, we express \(w\) as colour. Blue is kata, cream is \(w = 0\) and orange is ana. Two sections of rope only touch if they are in the same place and share the same colour.
Freely changing rope crossings is enough to untie any knot. Pick a starting point on any knot diagram and walk once around the entire geometry. Whenever you reach a crossing for the first time, make your strand the upper one, leaving it be if it already is. The new diagram is always equivalent to the unknot.
So every knot turns into the unknot after some crossing changes, and in \(\mathbb{R}^4\) every crossing change is free. Even friction doesn’t hold your knot taut as the cascading four-dimensional waves batter your vessel, bullying your rope until it comes undone.
The problem is codimension, the dimension of the space minus the dimension of the object in it. A rope is 1D, contorted in three dimensions, giving it a codimension of 2. That’s 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 even the unknot doesn’t work. Passing a closed loop of rope around a bollard just results in it slipping past the bollard ana once again. The harbourmaster smiles. He’s seen plenty of visiting sailors struggling with this, and kindly points you down the quay to a different kind of bollard.
The trouble is the linking number between the surface spanned by your rope (a 2-dimensional disc) and the bollard (a 1-dimensional line with a healthy bit of body fat in the other dimensions, including the fourth). Only the line matters, since the bollard can slim down to it without ever touching the rope. Call it the core. The linking number counts the points where the core passes through the disc, \(+1\) for each pass from front to back and \(-1\) for each pass from back to front. So a loop around a bollard has linking number \(\pm 1\), and a loop lying on the quayside has 0.
In three dimensions, the count can’t change while the loop remains intact. Crossings can only be destroyed if they pass outside the disc’s edge, and the edge is the rope. In other words, in three dimensions you cannot turn a configuration with linking number \(\pm 1\) to one with \(0\) without cutting the rope.
This only works when the core and disc cross at isolated points. In \(\mathbb{R}^n\), an \(a\)-dimensional object and a \(b\)-dimensional one cross at isolated points when \(a + b = n\), and can be nudged apart entirely when \(a + b < n\). On a 3D quay, \(2 + 1 = 3\), so the disc and the core cross at a point and the bollard holds. In \(\mathbb{R}^4\), \(2 + 1 < 4\). Nudge the core ana and it misses the disc altogether and your boat floats off. To cross the disc at a point again, the core needs one more dimension, \(2 + 2 = 4\). It has to be a plane.
The same count works for closed sheets too. Just as our loop of 1-dimensional string creates a 2-dimensional disc, looping a 2-dimensional surface makes a 3-dimensional ball. A closed \(p\)-dimensional loop spans a \((p+1)\)-dimensional disc, so a core of dimension \(q\) can hold it in \(\mathbb{R}^n\) when
\[p + q = n - 1.\]This is also satisfied by a 0-dimensional point in two dimensions.
The bollard you attempted to moor to was the obvious 4D version of a post, round in all three horizontal directions \(x\), \(y\) and \(w\), and running up in \(z\). Its core was a line. The harbourmaster’s bollard is round only in \(x\) and \(y\). It runs up in \(z\) and on forever ana and kata in \(w\), so its core is the \(zw\)-plane.
You can see the difference by looking at the harbour one slice at a time. The slice at a fixed \(w\) is an ordinary 3D space.
The round bollard thins out as you move ana, like the slices of a ball, and then stops. The rope steps ana past its 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.
The harbourmaster runs a coil of rope around his long bollard and a cleat of the same shape on your deck, and splices the ends together to form the loop. Your boat is at last moored, and without a single knot.
The boat is safe, but every knot you know is 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 with lament and passes you a tarpaulin. “If it’s knots ye want, give up on rope.”
A tarpaulin is 2D, so in \(\mathbb{R}^4\) its codimension is 2, the same as rope in 3D. That’s the room knots need. Lifting one patch of sheet past another would need a spare dimension, and a sheet in \(\mathbb{R}^4\) has none. That alone doesn’t prove any sheet is knotted, though. We’d best define exactly what we’re after.
Close the tarpaulin up into a bag with no opening, a sphere. The plainest sphere is the skin of a ball sitting in a single 3D slice. A sphere in \(\mathbb{R}^4\) is knotted if no amount of moving it around, without passing it through itself, turns it into that plain one. It’s the same idea as rope, where a knot is a loop you can’t move to a plain circle.
Emil Artin built the first one in 1925, by taking a knotted rope and spinning it.
Spinning in 3D is nice and easy. Spin a semicircle about the line through its two ends and it sweeps out a sphere. In 4D you spin about a plane instead of a line. A rotation that mixes \(x\) and \(w\) leaves the \(yz\)-plane where it is and carries every other point round a circle: out ana, back through ordinary space on the far side of the plane after half a turn, and home through kata.
So let’s do what Artin did and spin a knot in four dimensions. Make a simple trefoil knot and cut it once. Take the two fresh ends of the rope, rest them on a plane, and spin it. The ends stay put, the rest of the arc sweeps round, and out comes a knotted sphere with a copy of the knotted arc at every angle of the turn.
To make it from the tarpaulin, lay tarpaulin everywhere the arc passes as it spins. From the figure, it might look like the tarpaulin passes through itself, but in your four dimensions you can see they’re at different \(w\).
You can look at the knotted sphere the way you looked at the bollards, one slice at a time.
At \(w = 0\) the slice is the arc joined to its mirror image, a right-handed trefoil joined to a left-handed one. Move ana or kata and the parts nearest the plane drop out of the slice, so the knot breaks into loops that shrink and vanish at the sphere’s edge.
Artin proved that no motion in four dimensions turns this sphere into the plain one, just as no motion in three turns a trefoil into a plain loop.
The tarpaulin rescues the round bollard too. A sheet has \(p = 2\), so a line core holds it. Pick any \(z\) position and look at the \((x, y, w)\) 3D slice there, where the round bollard is a ball. Wrap the tarpaulin all the way round that ball and fuse its edges together, the way the harbourmaster spliced the rope, so the ball is sealed inside a closed bag.
By morning the four-dimensional swell has calmed, and it’s time to go. Your boat has spent the night moored twice over, because you were having too much fun to stop at one. There’s the harbourmaster’s rope, spliced round his long bollard with its plane core, and your tarpaulin, sealed round the round bollard with its line core and a round cleat on your deck. You reach for them, but there’s nothing to untie. Both are closed up, and the linking number that kept your boat safe all night works both ways. Neither can come off while it stays closed.
The harbourmaster is already walking down the quay with a knife. “Same as mooring,” he says, “only backwards.” He cuts the rope, and the loop falls open. He slits the tarpaulin, and with an edge again it slides off the bollard. He bundles it up and tosses it aboard. “Ye’ll want that where you’re going.”
You push off and wave as the quay drops away off your kata stern. You’re setting out to explore the Bermuda Tetrahedron, where ships slip away ana and are never seen again. You’d better brush up on your four-dimensional fluid mechanics first (coming soon).
Fair winds, sailor, and keep a tarpaulin aboard.
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.