Unverified 2026

Power-Law Volterra Memory

Implementation & benchmark of arXiv:2608.05679 — Small ball probabilities and Chung's law of the iterated logarithm for Gaussian Volterra processes with power-type kernels

Usefulness6/10
Difficulty6/10
Novelty6/10

Source paper: Small ball probabilities and Chung's law of the iterated logarithm for Gaussian Volterra processes with power-type kernels arXiv:2608.05679 ⓘ · analyzed Aug 31, 2026

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

Idea description

Add a causal memory branch whose weights are generated by the paper's power-type Volterra kernel rather than learned independently at every lag. Learn or softly constrain the exponents so the model can select rough short-memory behavior or smoother long-memory behavior while using only a few parameters. The branch can be implemented as a truncated causal convolution, a multiresolution approximation, or a recurrent state-space realization.

Formulas

$$X(t)=\int_{0}^{t}r^{\alpha}\left(\int_{r}^{t}u^{\beta}(u-r)^{\gamma}\,du\right)dW_{r},\qquad t\geq 0,$$
$$\alpha>-\frac{1}{2},\qquad \gamma\in\left(-1,-\frac{1}{2}\right),\qquad H:=\alpha+\beta+\gamma+\frac{3}{2}>0,$$
$$K_{ij}=t_j^{\alpha}\int_{t_j}^{t_i}u^{\beta}(u-t_j)^{\gamma}\,du,\qquad m_i=\sum_{j=0}^{i-1}\widetilde K_{ij}Vx_j,$$
$$\widetilde K_{ij}=\frac{K_{ij}}{\sum_{k<i}|K_{ik}|+\varepsilon},\qquad y_i=x_i+g_i\odot m_i,$$

Mathematical statement

The paper studies the Gaussian Volterra process X(t)=∫_0^t K(t,r)dW_r with K(t,r)=r^α∫_r^t u^β(u−r)^γdu, under α>−1/2, γ∈(−1,−1/2), and H=α+β+γ+3/2>0. Here t is time, r is the integration time, W is standard Brownian motion, α and β control the scale dependence of the kernel, γ controls the singularity as u approaches r, and H is the self-similar scaling exponent. The paper states that γ+3/2 determines local roughness and the small-ball exponent, α+β determines local fluctuation scale at positive times, and H governs scaling near the origin and infinity. We transplant the deterministic covariance/kernel shape into a neural memory filter: for discrete times t_i=iΔ, define K_{ij}=t_j^α∫_{t_j}^{t_i}u^β(u−t_j)^γdu for j<i, then normalize each row to unit absolute sum. The singularity restriction γ∈(−1,−1/2) gives a deliberately rough near-diagonal component, while H controls how memory magnitude changes with sequence scale. No Gaussian-process theorem is required for the module; the mathematically motivated asset is the separable power-law control of roughness and scale.

Implementation notes

Integrate the idea at the residual-stream level of a causal Transformer, SSM, or RNN. Given hidden states x[0:L,d], project them with V∈R^{d×d_m}, compute a causal Volterra memory m[i] from earlier projected states, and add a gated residual y[i]=x[i]+g[i]⊙m[i], where g[i]=sigmoid(linear(x[i])) and ε=10^{-6}. Use t_i=(i+1)/L, initialize α=0, β=0, and γ=−0.75; parameterize α=−0.5+softplus(a), γ=−1+0.5·sigmoid(c) so that α>−1/2 and −1<γ<−1/2, and set β=H−α−γ−3/2 with H=softplus(h), or initially keep all exponents fixed. Precompute K[i,j] on the maximum context length using numerical quadrature, a closed-form incomplete-beta implementation, or a 32-bin logarithmic-lag approximation. For an efficient MVP, approximate the integral by midpoint quadrature with 4–8 points per interval and truncate to a power-of-two window; alternatively approximate the resulting lag weights by a sum of 8 exponentials and evaluate the memory with eight recurrent states, reducing O(L²) cost to O(8L). Pseudocode is: compute t; for i in 1..L, for j<i evaluate K[i,j], row-normalize to Ktilde, accumulate m[i]=sum_j Ktilde[i,j]@(x[j]@V), then y[i]=x[i]+sigmoid(Gx[i])⊙(m[i]@O). The paper determines the admissible exponent region and interprets γ+3/2 as roughness and H as scale; quadrature error, truncation length, and whether learned exponents improve validation loss must be measured empirically. First experiment: replace one recurrent layer or one Transformer long-context block in a 125M-parameter language model and train on WikiText-103 or PG19 with 2k–8k contexts. Compare against a same-parameter dilated convolution and a diagonal SSM at equal FLOPs. Success means lower perplexity at long contexts, better loss on sequences longer than training length, or equal perplexity with fewer memory states; also report wall-clock cost and gradient-norm stability as γ approaches −1/2.

Verification

This idea has not been verified yet.

Verification happens in two stages: Stage 1 — a mechanism check on a toy system confirms the claimed mathematical phenomenon reproduces; Stage 2 — a benchmark implements the idea on a real (small) neural network task and compares it against a tuned baseline over 8 paired seeds with a permutation test.

Artifacts

Artifacts unavailable.