✗ Failed on benchmark 2026

Contour-resolvent state-space layer

Implementation & benchmark of arXiv:2607.12628 — Contour integral methods and structured perturbations for linear differential-algebraic equations

Usefulness7/10
Difficulty6/10
Novelty6/10

Source paper: Contour integral methods and structured perturbations for linear differential-algebraic equations arXiv:2607.12628 ⓘ · analyzed Aug 30, 2026

AI-generated research hypothesis, automatically tested. Not peer-reviewed.

Idea description

Replace repeated time-stepping of a stiff linear state-space block with a quadrature approximation to its inverse Laplace transform. The layer propagates a hidden state using a small set of complex shifted linear solves, which can be batched and reused across many time steps or parameter values.

Formulas

$$E\dot{x}(t)=Ax(t)+f(t),\qquad E,A\in\mathbb{R}^{n\times n},\quad x(t)\in\mathbb{R}^n.$$
$$\widehat{x}(s)=(sE-A)^{-1}Ex_0.$$
$$x(t)=\frac{1}{2\pi i}\int_{\Gamma}e^{st}(sE-A)^{-1}Ex_0\,ds\;\approx\;\operatorname{Re}\sum_{j=1}^{q}w_je^{s_jt}(s_jE-A)^{-1}Ex_0.$$
$$h_{k+1}=\operatorname{Re}\sum_{j=1}^{q}w_je^{s_j\Delta t}(s_jE-A(\theta))^{-1}Eh_k+b_k.$$

Mathematical statement

The paper studies the descriptor system $E\dot{x}(t)=Ax(t)+f(t)$, where $x(t)\in\mathbb{R}^n$ is the state, $E,A\in\mathbb{R}^{n\times n}$, and singular $E$ encodes algebraic constraints. For zero forcing and initial state $x_0$, the Laplace-domain solution is $\widehat{x}(s)=(sE-A)^{-1}Ex_0$, where $s\in\mathbb{C}$ and $(sE-A)^{-1}$ is the resolvent of the matrix pencil. Inverse Laplace reconstruction integrates this resolvent over a contour $\Gamma$ in the resolvent set: $x(t)=\frac{1}{2\pi i}\int_\Gamma e^{st}(sE-A)^{-1}Ex_0\,ds$. Nodes $s_j\in\Gamma$ and quadrature weights $w_j$ yield the computable approximation $\operatorname{Re}\sum_jw_je^{s_jt}(s_jE-A)^{-1}Ex_0$; taking the real part is valid when nodes and weights occur in conjugate pairs. The transferable property is stiffly stable propagation through resolvent solves instead of explicit steps constrained by the fastest eigenvalue.

Implementation notes

Integrate this at the state-transition operation of a linear SSM, recurrent block, or continuous-depth residual block. Let the hidden width be $n$, choose a descriptor matrix $E$ and a trainable dynamics matrix $A(\theta)$, and replace Euler or bilinear propagation with the contour update. Choose $q$ conjugate-symmetric nodes, for example $s_j=\sigma+\rho e^{i\phi_j}$ on a parabolic or Talbot-like contour, together with quadrature weights $w_j$. For each node, solve $(s_jE-A)z_j=Eh_k$ and set $h_{k+1}=\operatorname{Re}\sum_jw_je^{s_j\Delta t}z_j+b_k$. If $A$ and $E$ are fixed across sequence positions, cache one LU factorization per node; if $A$ changes slowly, reuse preconditioners or use batched Krylov solves. With $E=I$, this is a drop-in stiff SSM; with singular $E$, it becomes a descriptor SSM. The paper supplies the resolvent propagation rule, while contour shape, node count, and truncation tolerance should be selected by comparing against a finer quadrature and monitoring the residual of the propagated system. First test a width-128 SSM on a stiff synthetic oscillator and on a small Long Range Arena task. Compare Euler, bilinear/Tustin, and exact matrix-exponential baselines at equal FLOPs. Measure loss descent, maximum stable $\Delta t$, gradient-norm variance, wall-clock time, and final sequence accuracy. A positive result is faster loss descent or a substantially larger stable step size at matched accuracy; a practical target is roughly $2\times$ larger stable steps or fewer propagation evaluations without perplexity degradation.

Verification

Failed on benchmark

Stage 1 · Toy mechanism gate: Passed ✓

Stage 2 · Mechanism transferred to benchmark: Not reproduced ✗

Stage 2 · Practical benchmark result: Inconclusive

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 numerically verified a contour-resolvent propagator for a stiff linear system. The mechanism manifested: Euler’s predicted stability boundary dt=2/L was observed across L=10,100,1000; contour quadrature error decreased rapidly from 1.17 at q=64 to 2.6e-9 at q=2048; and converged contour propagation remained stable at dt=4/L where Euler diverged to 2.8e47, matching the exact solution to about 1e-7 relative error. This is a stability/accuracy result, not a speed win: q=2048 was about 2500x slower than Euler in the unoptimized uncached implementation.

Agent confidence
9/10
Baseline
Euler: unstable at dt=4/L, final norm 2.83e47 after 100 steps; bilinear: stable, relative error 2.25e-1 in the 250-step benchmark, 0.0085 s.
Idea
Contour q=2048: stable at dt=4/L with relative errors 1.3e-9, 2.6e-7, and 2.6e-7 for L=10,100,1000; benchmark relative error 2.25e-1 and 21.29 s. Quadrature sweep q=64,128,256,512,1024,2048 gave errors 1.17, 0.410, 0.0922, 0.00718, 5.09e-5, 2.59e-9.

Limitations: Only a 2-dimensional diagonal ODE with E=I was tested; singular descriptor systems, nonnormal dynamics, forcing, trainable SSMs, gradients, sequence tasks, GPU execution, LU-factorization caching, and optimized/batched solves were not tested. The circular contour is intentionally simple and requires a very large q for this stiff setup, so practical speed conclusions are unfavorable for this MVP.

How to run: python3 contour_resolvent_mvp.py

Stage 2 — Benchmark vs. tuned baseline (arXiv:2607.12628)

Ahead of the baseline (−11.7%) but not statistically significant (p=0.0529, wins 7 / 8 paired seeds).

Benchmark
Dynamics forecasting
Model
rnn_small
Paired seeds
8
Baseline mean
0.005
Idea mean
0.0044
Effect (Δ)
-0.0006 (−11.7%; negative = idea better)
Wins
7 / 8 paired seeds
p-value
0.0529 (permutation test, 20 000 shuffles)
Smallest detectable effect
±11.6%
Mechanism
Not confirmed ✗
Practical effect
Inconclusive
Baseline tuning
swept over 3 configs
Limitations:

Only the registered dynamics track was tested. Singular descriptor systems, nonnormal dynamics, forcing, LU-factorization caching, wall-clock speed, and larger hidden widths were not tested. The MVP uses diagonal learned dynamics and fixed circular quadrature with q=32 rather than general batched dense shifted linear solves.

How to run: python3 contour_bench.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 and trained a contour-resolvent recurrent state-space layer against a matched Euler-transition system on the structurally appropriate controlled-pendulum dynamics track. The idea had lower MSE and won 7 of 8 paired seeds, but the permutation p-value was 0.05285, so it did not meet the required significant-win criterion. The trained-model mechanism signature was confirmed: contour amplification remained below 0.0144 while Euler amplification reached 4.60.

Baseline
best_cfg={lr:0.003,dt:0.1}; full 8-seed mean test MSE=0.005005370418075472
Idea
best_cfg={lr:0.003,dt:0.5}; full 8-seed mean test MSE=0.004420042678248137; paired delta=-0.0005853277398273349; p_value=0.05285; idea_wins=7/8

Benchmark result

Ahead of the baseline (−11.7%) but not statistically significant (p=0.0529, wins 7 / 8 paired seeds).

Benchmark
Dynamics forecasting
Model
rnn_small
Paired seeds
8
Baseline mean
0.005
Idea mean
0.0044
Effect (Δ)
-0.0006 (−11.7%; negative = idea better)
Wins
7 / 8 paired seeds
p-value
0.0529 (permutation test, 20 000 shuffles)
Smallest detectable effect
±11.6%
Mechanism
Not confirmed ✗
Practical effect
Inconclusive
Baseline tuning
swept over 3 configs
Limitations:

Only the registered dynamics track was tested. Singular descriptor systems, nonnormal dynamics, forcing, LU-factorization caching, wall-clock speed, and larger hidden widths were not tested. The MVP uses diagonal learned dynamics and fixed circular quadrature with q=32 rather than general batched dense shifted linear solves.

How to run: python3 contour_bench.py

Artifacts

Implementation overview ⬇ Download all as ZIP 6 files · code, reports and structured results