State-compression ladder · Note M14 · Part VIII · capstone

Let the pieces come apart

Multiple shooting broke the long trajectory into blocks. But were the blocks still secretly wired together through the backward pass? We cut every wire and checked. They weren't — and the learning did not change by a single bit.

2026 · whitebox program capstone · Parts VI–VII pendulum · decoupled shooting

The arc so far: a long recurrence is expensive because each step waits on the one before it, and the credit path that trains it runs the whole depth backward. Multiple shooting cut a 1024-step differentiable trajectory into 256 four-step segments coupled by a continuity penalty, and that alone improved the learned field. But one thing was still centralized: a single optimizer held the whole autograd graph. So the real question — the one that decides whether this is a training trick or an architecture — had not been asked.

01The wire we hadn't cut

"Short segments" is not the same as "independent segments." If a gradient still has to flow from one block into its neighbour, the blocks cannot run on separate hardware — they are back to waiting on each other, just in a nicer-looking graph. The claim we wanted was stronger: that each four-step block can compute its own correction with no autograd graph crossing a boundary at all, exchanging only a tiny boundary note, and that summing those independent corrections reproduces exactly what the centralized optimizer would have done.

02Cut the wires, keep the objective

The mechanism is a detach pattern. Each segment sees its neighbours' boundary values as constants, not as things to backpropagate through:

c_right = end_i − s_next.detach() → gradient to θ, s_i
c_left  = end_prev.detach() − s_i → gradient to s_i only

Because the two copies detach complementary variables, every variable's gradient is produced exactly once, by its own segment. The test that this changed execution and not the objective is a hard invariant, checked before any other claim: the sum of the boundary-local gradients must equal the gradient of the original joint objective.

max |Δg| = 0.00e+00. Not "within tolerance" — bit-for-bit identical.

03Exact, all the way to the rollout

The invariant guarantees identical gradients at one step. Run the identical schedule end to end and the free-running rollouts come out identical too — per seed, to the last digit.

So this is not an approximation that happens to be close. It is the same computation, executed without the long dependency. The continuity stays tight (||c|| ~ 3e-4) and the boundary multiplier stays bounded (||λ|| ~ 17) — the augmented-Lagrangian coupling is healthy, not chasing a moving target.

04Does independence buy speed?

Proving the segments can run apart is not the same as measuring that they run faster. So one small, honest benchmark: real worker processes, each owning a chunk of segments, exchanging only boundary notes and summing the shared gradient. Not optimized.

The honest reading: the exposed parallelism does convert to ordinary wall-clock speedup — about 3× here — and the shortfall from linear is entirely the expected overhead, not a flaw in the decomposition. On a GPU the mechanism is different and cheaper still: all 256 segments already pack into a single kernel, because — and this is the whole point — nothing forces them into sequence.

05What we did and did not earn

Precision matters here more than triumph. Three things are true; a fourth is not:

claim	status
no full-horizon 1024-step BPTT	proven removable
no autograd graph across a boundary	proven (bit-identical)
independence gives real speedup	~3× measured
no backprop at all	not this — 4-step BPTT still runs inside each segment

We removed the long-range credit path, not backprop as such. Inside each four-step block the ordinary forward/backward is alive and well; what vanished is any dependency that reaches across a segment. And the speedup is ~3× on this machine, not 256× — parallelism exposed, its realization capped by real hardware. Eliminating those last four backward steps (forward sensitivities, eligibility traces) is a separate question, and given how cheap a four-step BPTT is, probably not a rewarding one.

06The lesson of the whole sweep

We began the credit thread expecting to need a cleverer long-range rule — target propagation, synthetic gradients, something that approximates the missing gradient. We never used one. A plain continuity penalty already beat exact global credit; a boundary multiplier tightened it; and then the graph came apart with no loss at all. The pattern that keeps recurring in this program held one more time:

Don't replace a long credit path with a cleverer long-range rule. Restructure the problem until the credit is local — then the simplest possible signal is enough, and the pieces come apart on their own.

That closes the multiple-shooting arc. The long backward dependency, which looked like the essence of training a dynamical system, turned out to be a property of how we wrote the problem, not of the problem itself. The next question is not about credit at all: it is whether this same decoupling survives a substantially harder flow — stiffer, more nonlinear — before chaos gets the final word.

---

Part of the whitebox / MorphoHDL program. Capstone of the multiple-shooting arc (Parts VI–VII). Forced pendulum, shared 2-layer vector field, Euler integration, T_block = 4 (256 segments); augmented-Lagrangian / method-of-multipliers boundary coupling (not textbook ADMM — no alternating primal blocks). Gradient-equivalence invariant and per-seed rollout match verified before any speedup claim; parallel benchmark on real worker processes, 8-core CPU, unoptimized.