Inertial asynchronous recurrent computation
Implementation & benchmark of arXiv:2607.21965 — Inertial Asynchronous Computation
Source paper: Inertial Asynchronous Computation arXiv:2607.21965 ⓘ · analyzed Aug 30, 2026
AI-generated research hypothesis, automatically tested. Not peer-reviewed.
Idea description
Replace each recurrent neural state with two asymmetrically coupled variables: a slow state x_i and a fast momentum or drive variable v_i. Each coordinate or block updates independently using its locally available, possibly stale input; the auxiliary variable supplies inertia that suppresses harmful update-order sensitivity and can accelerate traversal toward a retrieved state or denoised solution.
Formulas
Mathematical statement
The paper's baseline asynchronous Hopfield computation is x_i(t + Delta t) = sign(sum_j J_ij x_j(t) + eta_i(t)), where x_i is a binary state, J_ij is the coupling matrix, and eta_i is white noise. Transfer this mechanism to a differentiable neural state with tau_x dot{x}_i = -x_i + v_i and tau_v dot{v}_i = -v_i + F_i(x), where x_i is the recurrent representation, v_i is its inertial auxiliary state, tau_x and tau_v are positive time constants, and F_i(x) = phi(sum_j W_ij x_j + b_i) is the neural drive. Linearizing around a fixed point and writing F(x) approximately Jx, a mode with Jacobian eigenvalue lambda obeys tau_x tau_v s^2 + (tau_x + tau_v)s + (1 - lambda) = 0. For a real-spectrum Jacobian, asymptotic stability requires lambda < 1. The stable mode becomes underdamped when 4 tau_x tau_v(1 - lambda) > (tau_x + tau_v)^2. These conditions provide measurable stability and oscillation boundaries for asynchronous neural inference.
Implementation notes
1. Integration point: implement this as a recurrent layer, denoising autoencoder bottleneck, or continuous-time state-space block. Maintain tensors x and v with the same shape as the hidden state. Partition coordinates into asynchronous blocks, such as individual neurons, rows, or random one-to-five-percent subsets, and do not synchronize all blocks after every event. 2. Event pseudocode: initialize x and v; repeatedly sample a block B; read the most recent locally cached x values; compute u_B = phi(W_B x + b_B); update v_B <- v_B + (delta/tau_v)(-v_B + u_B); update x_B <- x_B + (delta/tau_x)(-x_B + v_B); leave all other coordinates unchanged; optionally add Gaussian noise with variance sigma squared to u_B. For discrete training, unroll K asynchronous events and backpropagate through the updates, or use the block dynamics only at inference. 3. Computed quantities: W, phi, and the local drive are ordinary network operations. Estimate the dominant Jacobian eigenvalue lambda_max by ten to twenty power iterations on the current hidden state, and estimate relaxation rates from the autocorrelation or an exponential fit of norm(x(t) - x*) . The paper supplies the inertial two-part mechanism and asynchronous event interpretation; the exact neural Jacobian and phase location must be measured. 4. First cheap experiment: use a two-layer tanh autoencoder on MNIST with Gaussian-corrupted inputs, comparing a standard synchronous recurrent denoiser, asynchronous first-order updates, and the inertial asynchronous layer at equal numbers of coordinate updates. Sweep the recurrent gain g multiplying W and the ratio tau_x/tau_v. The predicted signature is a sharp divergence or persistent-oscillation boundary near g lambda_max(W_normalized) = 1, with the measured boundary within roughly twenty percent of the linear prediction. Below the boundary, log norm(x(t) - x*) should show exponential decay; in the underdamped region it should show decaying oscillations, while excessive gain should produce nondecaying activity or saturation. Also test update-order robustness: variance of final reconstruction error across random event schedules should be lower for the inertial system than for first-order asynchronous updates.
Verification
Stage 1 · Toy mechanism gate: Passed ✓
Stage 2 · Mechanism transferred to benchmark: Not reproduced ✗
Stage 2 · Practical benchmark result: Significantly worse ✗
Methodology: 8 paired seeds, permutation test (p<0.05) against a learning-rate-tuned baseline. How verification works
Stage 1 — Mechanism check agent confidence 9/10
Built and reran a readable linear inertial-asynchronous recurrent simulator with numerical sweeps. The predicted stability boundary lambda=1.0 was observed at 1.025, the underdamped boundary -0.8 was observed at -0.825, and measured decay rates matched analytic roots closely, with absolute discrepancies of about 0.0002-0.0010. The mechanism manifested, although the small asynchronous comparison did not show a reconstruction or convergence win: inertial updates had higher final norm while schedule variance was only slightly lower.
- Agent confidence
- 9/10
- Baseline
- First-order asynchronous: final norm mean 0.14107, std 0.00032869
- Idea
- Inertial asynchronous: final norm mean 0.18233, std 0.00031723; stability boundary 1.025 vs predicted 1.0; oscillation boundary -0.825 vs predicted -0.8; decay-rate errors <= 0.0010
Limitations: No MNIST/autoencoder experiment, nonlinear tanh Jacobian estimation, GPU test, or wall-clock/FLOP comparison was performed. The asynchronous toy comparison uses independent scalar modes rather than a coupled neural weight matrix and therefore only provides a secondary signal.
How to run: python3 inertial_async_experiment.py
Stage 2 — Benchmark vs. tuned baseline (arXiv:2607.21965)
Significantly WORSE than the tuned baseline (+19.2%, p=0.0081, wins 0 / 8 paired seeds).
- Benchmark
- Dynamics forecasting
- Model
- rnn_small
- Paired seeds
- 8
- Baseline mean
- 0.0034
- Idea mean
- 0.0041
- Effect (Δ)
- 0.0007 (+19.2%; negative = idea better)
- Wins
- 0 / 8 paired seeds
- p-value
- 0.0081 (permutation test, 20 000 shuffles)
- Smallest detectable effect
- n/a
- Mechanism
- Not confirmed ✗
- Practical effect
- Hurts
- Baseline tuning
- swept over 3 configs
Only the built-in dynamics track was tested; no vision, sequence, or custom-track transfer was evaluated. The mechanism signature measured one trained model and a short relaxation trajectory, not a broad sweep of Jacobian spectra or asynchronous event schedules.
How to run: python3 bench_inertial_dynamics.py
Verdict computed by deterministic test code from paired-seed statistics — not by the language model.
Stage 2 — Benchmark latest Failed ✗
Agent confidence: 9/10
Implemented an end-to-end inertial recurrent dynamics model with matched input, drive, and readout modules against a first-order recurrent baseline on the structurally matched controlled-pendulum rollout track. The trained-model mechanism signature confirmed the stable/non-underdamped prediction, but the idea was significantly worse: MSE 0.0041087 versus 0.0034458, paired delta +0.0006630, permutation p=0.0081. Therefore the mechanism transferred numerically but did not improve benchmark training.
- Baseline
- Best lr=0.005; 8-seed test MSE mean 0.0034457602, std 0.0007198716
- Idea
- Best lr=0.005, tau_x=1.0, tau_v=0.2; 8-seed test MSE mean 0.0041087228, std 0.0007584494; paired delta +0.0006629626; p=0.0081
- Mechanism signature
- Predicted lambda=-0.06094, predicted underdamped=false; observed decay rate=0.29527, one sign change, observed underdamped=false; confirmed=true
Benchmark result
Significantly WORSE than the tuned baseline (+19.2%, p=0.0081, wins 0 / 8 paired seeds).
- Benchmark
- Dynamics forecasting
- Model
- rnn_small
- Paired seeds
- 8
- Baseline mean
- 0.0034
- Idea mean
- 0.0041
- Effect (Δ)
- 0.0007 (+19.2%; negative = idea better)
- Wins
- 0 / 8 paired seeds
- p-value
- 0.0081 (permutation test, 20 000 shuffles)
- Smallest detectable effect
- n/a
- Mechanism
- Not confirmed ✗
- Practical effect
- Hurts
- Baseline tuning
- swept over 3 configs
Only the built-in dynamics track was tested; no vision, sequence, or custom-track transfer was evaluated. The mechanism signature measured one trained model and a short relaxation trajectory, not a broad sweep of Jacobian spectra or asynchronous event schedules.
How to run: python3 bench_inertial_dynamics.py
Artifacts
- bench_inertial_dynamics.py 5.3 KB View Raw
- bench_report.json 2.9 KB View Raw
- inertial_async_experiment.py 3.6 KB View Raw
- report.md 1.4 KB View
- report_bench_2026-08-30T234416.md 4.5 KB View
- results.json 5.8 KB View Raw