State-compression ladder · Note M14 · Part IV
A fair hardware benchmark of the space↔time transpose against a competent, tuned GRU at a 784-step horizon. The transpose wins decisively and predictably — and the fancy part turns out to be unnecessary.
Part III found a knee on a toy 64-step task with a tiny tanh cell: shortening the recurrent horizon by spatial replication recovered nearly all the accuracy at a fraction of the cost. The obvious objection was that the baseline was a vanishing-gradient straw man. So we scaled up — a real GRU, sequential MNIST (784 pixels, one per tick, fixed permutation), and the fairest test we could design.
Every architecture factors the same 784-step sequence as S × T = 784 — S parallel GRU lanes of horizon T — and is judged on the metric that actually matters for hardware: accuracy versus elapsed training seconds, not accuracy after a fixed epoch count that would silently favour the cheaper models. Crucially, every arm gets the same learning-rate calibration budget, so the long-horizon baseline cannot be dismissed as poorly tuned. Same GRU width, optimizer, data, initialization family throughout.
| arm (S×T) | acc | acc @30s | hits 90% | crit-depth | latency |
|---|---|---|---|---|---|
| full BPTT 1×784 | 0.706 | 0.208 | never | 784 | 75.7 ms |
| tree 7×112 | 0.850 | 0.856 | never | 115 | 11.6 ms |
| tree 14×56 | 0.858 | 0.870 | never | 60 | 6.2 ms |
| tree 28×28 | 0.867 | 0.880 | never | 33 | 3.7 ms |
| tree 49×16 | 0.883 | 0.889 | never | 22 | 2.5 ms |
| transpose 49×16 | 0.917 | 0.920 | 2.2 s | 16 | 1.83 ms |
| tree 98×8 | 0.874 | 0.884 | never | 15 | 1.79 ms |
Honest framing: this is a Pareto result, not a knockout. The full-BPTT GRU reached only 0.706 in the budget and would very likely keep climbing with far more time. What it cannot do is compete per second: it is ~40× slower per update and starts credit-starved.
The most useful result is not any single number — it is that a crude model predicts the hardware. The critical path of an S×T factorization is about T + ⌈log₂S⌉. Plot measured GPU latency against it:
The optimum is a hybrid. Accuracy climbs to ~49×16 and then saturates; latency keeps falling. Neither the pure-temporal extreme (slow and credit-starved) nor the maximally-spatial one is best — exactly the knee Part III predicted, now at 12× the horizon.
Here is the finding that sharpens the whole idea. At the knee we ran two arms with the same short horizon: bpts_tree, which recursively composes the block states through a trainable spatial tree (the "real" backprop-through-space), and transpose_lin, which simply concatenates the block states and reads them with one linear layer. The simple one won:
transpose + linear: 0.917 vs spatial tree: 0.883.
The recursive tree compresses S block states down to a single vector through lossy combiners — a bottleneck — while the linear readout sees them all. So the deep spatial-credit machinery adds no representational value here. The leverage is the space↔time transpose itself — shortening the recurrent horizon and running the lanes in parallel — not credit assignment through a spatial hierarchy. What we have demonstrated is the transpose; the "real BPTS" step did not earn its keep on this task.
So the honest name is not backprop-through-space but the space↔time transpose (STT): a long sequence split into many short, shared-recurrent blocks run in parallel, their final states simply concatenated for a cheap wide readout.
Use recurrence locally; use a parallel spatial representation globally.
The trade is explicit in the ledger: STT exchanges long recurrence for more parallel blocks and a wider readout — 49×32 = 1568 features, more simultaneous state. But it is not merely buying accuracy with width. 98×8 carries more simultaneous state than 49×16 and scores lower — so the sweet spot is a genuine temporal/parallel balance, not the biggest model.
Set against the two earlier negatives, the shape of the whole programme is now clear: a richer substrate (M13.5) and richer relationships (M14) did not buy accessible robust computation, but a change to where sequential depth lives did — and on real hardware it buys a large, predictable latency and accuracy-per-second advantage.
Long temporal chains are expensive to both learn and run. A modest amount of spatial parallelism keeps the learning path short and the latency low — and the cost is predicted, almost exactly, by one number: the critical-path depth.
Two questions remain genuinely open. First, since the spatial tree added nothing, the real BPTS test is whether cheap local or direct credit between blocks can match exact backprop — the path toward physical, on-chip learning. Second, the primitive question: which recurrences are expressive enough for the task and compose associatively, so that even the within-block temporal steps admit a parallel scan. Those are where the architecture goes from a measured win to a design.
Part of the whitebox / MorphoHDL program. Part IV of a series with M13.5 (Part I), M14 (Part II), and Part III. Benchmarked on an NVIDIA L4; GRU d=32; sequential permuted MNIST; wall-clock as the independent variable; every arm given the same learning-rate calibration budget so the long-horizon baseline is tuned, not a straw man.