Application

Quantum reservoir computing for volatility forecasting: what the evidence says

We tested a 6-qubit quantum reservoir on a noiseless simulator against HAR and other classical baselines, forecasting realised volatility one step ahead on two series, and read the one published study on S&P 500 volatility. In our run the plain HAR regression was the most accurate model on both series, and the quantum reservoir was significantly worse than HAR on every seed. The published study reports the lowest loss for its 10-qubit quantum reservoir, with three classical models statistically tied with it, also on a noiseless simulator. So far, at these sizes, a quantum reservoir has not beaten the classical baselines in a way that holds up; this page says what would have to change and how to test it on your own series.

Updated

The short answer

Most accurate model in our run
HAR, a linear regression on the current volatility and its weekly and monthly averages, on both series and by both losses. A plain autoregression came within a hair of it. No model beat HAR significantly for any seed
Quantum reservoir against HAR
Its mean squared error was 1.10 times HAR's on the daily series and 1.20 times on the monthly one, significantly worse on every seed by a Diebold-Mariano test
Against the other baselines
It tied the classical echo state network with the same readout on the daily series and lost to it on the monthly one. It beat the LSTM on the daily series and lost to it on the monthly one. By error it ranked 4 of 6 on the daily series and 5 of 6 on the monthly one
The published S&P 500 result
Li et al. report the lowest one-month-ahead MSE for their 10-qubit reservoir QR2, 0.103[1] against 0.1089[1] for a classical reservoir with extra predictors, but the 95% model confidence set also holds three classical models. At a five-month horizon the classical reservoir had the lowest MSE
What this is not
A trading signal or a statement about any market. Our run uses an air-quality series and a synthetic one, and the paper ran on a noiseless simulator. Nothing on this page ran on quantum hardware

The forecasting task and the classical baseline

Realised volatility measures how much a series moved inside one period. For returns rt,ir_{t,i} observed within period tt it is RVt=∑irt,i2RV_t = \sqrt{\sum_i r_{t,i}^2}, and forecasting work usually models its logarithm yt=log⁡RVty_t = \log RV_t, which is closer to Gaussian. The task on this page is the simplest one in that literature: forecast yt+1y_{t+1} from what is known at tt.

The baseline every new method has to beat is Corsi's heterogeneous autoregressive model, HAR[2]. It regresses the next value on three averages of the past, over one period, a week and a month:

y^t+1=β0+βd yt+βw yˉt−4:t+βm yˉt−21:t\hat{y}_{t+1} = \beta_0 + \beta_d\, y_t + \beta_w\, \bar{y}_{t-4:t} + \beta_m\, \bar{y}_{t-21:t}

Four coefficients fitted by least squares capture most of the long memory that volatility shows, which is why HAR is hard to beat. Forecasts are scored by mean squared error on the log scale and by QLIKE on the variance scale, a loss that stays consistent when the realised measure is a noisy proxy for the true variance[3]:

QLIKE=1n∑t(RVt2ht−log⁡RVt2ht−1),ht=e2y^t\text{QLIKE} = \frac{1}{n}\sum_t \left(\frac{RV_t^2}{h_t} - \log\frac{RV_t^2}{h_t} - 1\right), \qquad h_t = e^{2\hat{y}_t}

A reservoir model takes a different route. A fixed dynamical system, the reservoir, is driven by the input series, and only a linear readout on its states is trained. In a quantum reservoir the system is a set of qubits, and the features are measurements of their state[6]. Training is one ridge regression, with no gradients through the circuit. The eigenkit chapter on reservoir computing explains the three steps: drive the reservoir, read out features, fit the readout.

The published study: S&P 500 monthly volatility

Li et al. forecast the log realised volatility of the S&P 500 one month ahead, from 815[1] monthly observations between February 1950 and December 2017, with the last 245[1] months out of sample on a rolling window. Their reservoir is a fully connected transverse-field Ising Hamiltonian on 10 qubits: 7[1] input qubits for macro-finance predictors picked by forward selection and 3[1] hidden qubits that carry the past. QR2 uses twice the measurements of QR1. The model confidence set[4] keeps every model that cannot be rejected as the best at the 95% level.

ModelMSEQLIKEIn the 95% confidence set
HAR0.1476[1]2.0431[1]no
AR(3)0.1178[1]1.5893[1]no
ARMAX, with macro predictors0.1145[1]1.6196[1]yes
LSTM0.1295[1]1.7909[1]no
LSTMX, with macro predictors0.1185[1]1.7571[1]yes
Classical reservoir (RC)0.1441[1]2.1011[1]no
Classical reservoir with macro predictors (RCX)0.1089[1]1.6480[1]yes
Quantum reservoir QR10.105[1]1.4427[1]yes
Quantum reservoir QR20.103[1]1.4004[1]yes

One-month horizon, Table II of the paper. HARX and AR(1) are left out; neither is in the set. At a five-month horizon the classical reservoir RC had the lowest MSE, 0.1528[1] against 0.1556[1] for QR1. The authors computed the measurement outcomes exactly in simulation, note that hardware would need many shots, and state that they do not claim a definitive quantum advantage[1].

Our run: six models on the same expanding window

We asked whether eigenkit's QuantumReservoirRegressor forecasts a realised-volatility series one step ahead better than HAR, AR, an LSTM and a classical echo state network (ESN). We found no equity-index history under an open licence, so the run uses two other series. The daily one is real: the realised volatility of hourly log changes of Beijing PM2.5 air pollution, 2010 to 2014 (UCI dataset 381, CC BY 4.0), with 508 test days. The monthly one is synthetic: daily GARCH(1,1) returns with Student-t shocks, 815 months with the last 245 out of sample, the shape of the S&P 500 study. Every model was refitted on the same dates of an expanding window, each tunable model got the same 6 configurations, and the seeded models ran 5 seeds.

ModelDaily MSEDaily QLIKEMonthly MSEMonthly QLIKE
HAR0.29470.68710.10010.2697
AR(p)0.29520.68790.10250.2755
Classical echo state network, 64 units0.3228 ± 0.00400.7410 ± 0.01940.1079 ± 0.00340.2904 ± 0.0162
Quantum reservoir, 6 qubits0.3229 ± 0.00260.7292 ± 0.01070.1197 ± 0.00320.3270 ± 0.0119
LSTM0.3544 ± 0.01540.8133 ± 0.05380.1070 ± 0.00290.3022 ± 0.0109
Random walk0.47572.20340.12590.3110

Run qrc-volatility-forecasting of 2026-11-03, mean and spread over 5 seeds, on Beijing PM2.5 hourly data (eigenkit dataset beijing_pm25, UCI #381), turned into daily log realised volatility of hourly log(1 + PM2.5) changes. Losses of the log-volatility forecast on the test window; mean ± standard deviation over 5 seeds where a model has a seed. The quantum reservoir and the ESN share the readout: a ridge regression on 64 features plus a bias, so the comparison between them isolates the reservoir. Daily series: air quality, not prices. Monthly series: synthetic. Neither says anything about a market.

Reading the run

HAR was the most accurate model, by a clear margin. On both series HAR had the lowest MSE and QLIKE, and the autoregression was almost level with it. Against HAR, the quantum reservoir's squared errors were significantly larger for every seed by a Diebold-Mariano test[5] at the 5% level. On the monthly series that is partly by construction: the next log volatility of a GARCH process is close to linear in its recent past, which is the form HAR fits.

Against the classical reservoir, the quantum one tied on the daily series. On that series the two had the same MSE within their spread, 0.3229 ± 0.0026 against 0.3228 ± 0.0040, with a slightly lower QLIKE for the quantum reservoir. On the monthly series the ESN was clearly ahead. Since both feed a 64-feature ridge readout, the circuit's features added nothing the readout did not already get from a random tanh network.

The LSTM result depends on the series. The quantum reservoir beat the LSTM on the daily series and lost to it on the monthly one. With 6 configurations per model, neither direction is a verdict on LSTMs, which are sensitive to tuning.

The circuit is the slow part. Over the daily test window the quantum reservoir took 17.1 s on eigenkit's NumPy statevector simulator, against 0.16 s for the ESN and 0.04 s for HAR. Each refit re-runs the reservoir over the whole series, because the carried state at a date depends on every input before it. On hardware the 64 probabilities at every step would each be estimated from shots, which the simulator skips.

What would change this result

The signal to look for is a quantum reservoir that beats HAR and a classical reservoir with the same readout, out of sample, by more than the seed-to-seed spread, under a Diebold-Mariano test or a model confidence set. Neither our run nor the published one shows that yet. Three things could move it, and each can be tested rather than assumed.

Predictors beyond the series itself. In the published study both quantum reservoirs were fed macro-finance predictors and sat in the model confidence set, next to the classical models that were given macro predictors too[1]; our run fed the reservoir one series only. The fair test adds the same predictors to every model, a classical reservoir included, and asks whether the quantum one leaves the tie.

A series that is not close to linear. On the monthly series the next log volatility is close to linear in its recent past by construction, which is the form HAR fits. A reservoir has more to offer where the dynamics are not, and the echo state network with the same readout tells you whether that gain is quantum or just reservoir computing. Larger reservoirs are the other lever, but their features concentrate as qubits are added[7], so check how much the features still vary with the input before you check the loss.

Real hardware. Both runs computed the measurements exactly, and on a device every feature at every step is a shot estimate, which the published study names as the cost hardware would add[1]. eigenkit's reservoir carries a statevector from step to step, so it does not run on a QPU today. What can be checked now is whether a spin system of this size evolves within today's error budgets.

HAR against a quantum reservoir in 30 lines

import numpy as np
from eigenkit import Encoding, QuantumReservoirRegressor, Variational

# 400 months of log realised volatility from simulated GARCH(1,1) daily returns.
rng = np.random.default_rng(2026)
var, r = 1e-4, np.empty(400 * 21)
for t in range(len(r)):
    r[t] = np.sqrt(var) * rng.standard_t(6) / np.sqrt(1.5)
    var = 2e-6 + 0.08 * r[t] ** 2 + 0.90 * var
y = 0.5 * np.log((r.reshape(400, 21) ** 2).sum(axis=1))
z = (y - y[:300].mean()) / y[:300].std()  # first 300 months train, last 100 test

# HAR inputs at month t: this month, the mean of the last 3 and of the last 12.
har = np.array([[z[max(0, t - k + 1) : t + 1].mean() for k in (1, 3, 12)] for t in range(400)])

# HAR: least squares of z[t+1] on the three inputs at t.
A = np.column_stack([np.ones(400), har])
coef = np.linalg.lstsq(A[11:299], z[12:300], rcond=None)[0]
har_mse = np.mean((A[299:399] @ coef - z[300:400]) ** 2)

# Quantum reservoir: 6 qubits driven by the HAR inputs (each used twice), leaky carry.
qrc = QuantumReservoirRegressor(
    [Encoding(in_features=6, rotation="RY"), Variational(depth=4, rotation="RY")],
    state_policy="leaky", leak=0.5, features="probabilities", ridge=1e-3, washout=12, random_state=0,
)
U = np.tile(har, (1, 2))[None]
qrc.fit(U[:, :299], z[None, 1:300])
qrc_mse = np.mean((qrc.predict(U[:, :399])[0, 299:] - z[300:400]) ** 2)

print(f"HAR {har_mse:.3f}, quantum reservoir {qrc_mse:.3f}")  # HAR 0.650, quantum reservoir 0.849

Runs in about a second with eigenkit 1.1.0 on the built-in NumPy simulator; errors are on the standardised scale. One split and no refits, so it is a sketch of the protocol, not the run above. With random_state from 0 to 4 the reservoir's error changed with the seed and stayed above HAR's every time. The prediction at month tt uses only inputs up to tt, because the reservoir is causal: the carried state is ψt∝α U(xt) ψt−1+(1−α) ∣0⋯0⟩\psi_t \propto \alpha\, U(x_t)\,\psi_{t-1} + (1-\alpha)\,|0\cdots0\rangle, with α\alpha the leak.

Testing a quantum reservoir on your own volatility series

If you want to know whether a reservoir helps on your data, this order keeps the comparison fair.

  1. Fit HAR first and write its loss down

    Four coefficients and a least-squares fit. Score it out of sample with MSE on log volatility and QLIKE on variance, on an expanding or rolling window with refits on fixed dates. Every other model is judged against this number.

  2. Add a classical reservoir with the same readout

    An echo state network with as many units as the quantum reservoir has features, and the same ridge penalty. Without it you cannot tell whether a gain comes from the quantum circuit or from reservoir computing itself.

  3. Configure the quantum reservoir for memory

    Use state_policy="leaky" with a leak between 0.3 and 0.7, as the state policies section recommends for temporal tasks; the default unitary carry has little memory a linear readout can use. Set washout to at least your longest HAR lag.

  4. Give every model the same tuning budget

    Choose configurations on a validation slice of the first training window only, then freeze them. A quantum model tuned harder than its baselines wins for the wrong reason.

  5. Vary the reservoir seed and test the difference

    The circuit weights are one random draw. Run several random_state values and compare each with HAR by a Diebold-Mariano test, or with a model confidence set when you compare many models[4]. A lower mean loss inside the noise is a tie.

  6. Count the shots before you plan for hardware

    On a device each feature at each step is an estimate from repeated measurements, and the carried state cannot be read out and fed back the way a simulator does it. Work out how many circuit runs one forecast needs at the precision your readout requires before treating hardware as the next step.

Questions

Can quantum reservoir computing forecast volatility better than HAR?

Not in our run. On a daily realised-volatility series and a synthetic monthly one, HAR had the lowest error and the quantum reservoir was significantly worse on every seed. The one published S&P 500 study reports the lowest loss for its 10-qubit quantum reservoir against a HAR that it beats clearly, but ARMAX, an LSTM with predictors and a classical reservoir with predictors were statistically tied with it.

Is quantum reservoir computing better than an LSTM for time series?

It depends on the series, and neither wins reliably. In our run the quantum reservoir beat the LSTM on the daily series and lost to it on the monthly one, with the same small tuning budget for both. A classical echo state network with the same readout did as well as or better than the quantum reservoir on both series, at a fraction of the cost.

How many qubits does a quantum reservoir need for volatility forecasting?

The published S&P 500 study used 10 qubits, 7 for inputs and 3 hidden qubits for memory; our run used 6. More qubits give more features, but measured features of large random reservoirs tend to concentrate, so the shots needed to read them grow quickly.

Can I run a quantum reservoir on a real quantum computer?

Not with eigenkit's reservoir today: it carries the state from step to step by injecting a statevector, so it runs only on simulators that expose one. On hardware each feature at each timestep would have to be estimated from repeated measurements, and the published volatility study also ran on a noiseless simulator.

Does a better volatility forecast mean better trading results?

This page does not say so. It compares forecast errors on test data, by mean squared error and QLIKE, and none of the results here has been tested on a market or in a trading or risk process.

Sources

  1. Q. Li, C. Mukhopadhyay, A. Bayat, A. Habibnia. Quantum reservoir computing for realized volatility forecasting. Physical Review Research 8, 023028, 2026. arXiv:2505.13933.
  2. F. Corsi. A simple approximate long-memory model of realized volatility. Journal of Financial Econometrics 7(2), 174–196, 2009.
  3. A. J. Patton. Volatility forecast comparison using imperfect volatility proxies. Journal of Econometrics 160(1), 246–256, 2011.
  4. P. R. Hansen, A. Lunde, J. M. Nason. The model confidence set. Econometrica 79(2), 453–497, 2011.
  5. F. X. Diebold, R. S. Mariano. Comparing predictive accuracy. Journal of Business and Economic Statistics 13(3), 253–263, 1995.
  6. K. Fujii, K. Nakajima. Harnessing disordered quantum dynamics for machine learning. Physical Review Applied 8, 024030, 2017. arXiv:1602.08159.
  7. W. Xiong, G. Facelli, M. Sahebi, O. Agnel, T. Chotibut, S. Thanasilp, Z. Holmes. On fundamental aspects of quantum extreme learning machines. Quantum Machine Intelligence 7, 20, 2025. arXiv:2312.15124.

Run it yourself with eigenkit

eigenkit is EigenOrbit's open-source Python library: write a circuit once, run it on any simulator or QPU, and test it against a classical baseline on your own data before you invest in it or rule it out.

$ pip install eigenkit