A synthetic benchmark for learning systemic portfolio-risk structure from a quantum representation. As the portfolio grows from 8 to 16 assets the classical kernel degrades toward chance (0.99) while the quantum representation keeps learning (0.69): the result is a persistent sample-efficiency gap that widens with portfolio size.

Each example is a correlated-asset risk regime encoded as a quantum state, paired with an exact systemic-risk label; the quantum representation is the ground state's single-qubit measurements. The data is synthetic — a finance-structured Hamiltonian — so this is a representation benchmark on a risk-shaped task, not a market, pricing, or trading claim.

What this is

Each row is a market regime defined by a one-factor correlation structure (asset loadings) and per-asset volatilities, encoded as a correlated-asset Ising Hamiltonian. quantum_features are the single-qubit expectation values of its ground state (the quantum representation); label is an exact systemic co-movement observable Σ_{i<j} C_ij ⟨Z_i Z_j⟩. The intended comparison is a quantum kernel on quantum_features against a classical kernel on the raw inputs — learning a function of quantum states, the regime where a quantum advantage is expected (Huang, Kueng, Torlai, et al. 2022, arXiv:2106.12627), not ordinary tabular finance, where classical kernels are competitive (Schuld, Bowles, et al. 2024, arXiv:2403.07059; Miyabe, Quanz, et al. 2023, arXiv:2312.00260).

Dataset structure

field	type	description
`n_assets`	`int`	portfolio size (8, 10, 12, 14, 16)
`inputs`	`list[float]`	upper-triangle correlation couplings `C_ij` (factor loadings) and per-asset volatilities `h_i`
`quantum_features`	`list[float]`	1-RDM expectations `⟨X_i⟩,⟨Y_i⟩,⟨Z_i⟩`, length `3·n_assets`
`label`	`float`	systemic co-movement `Σ_{i<j} C_ij ⟨Z_i Z_j⟩` (exact)

1,000 rows: 200 per portfolio size.

Result — sample complexity and scaling

Test error normalised by each kernel's shuffled-label level (1.0 = no learning), recomputed from the data in verification.json. The classical kernel degrades toward no-learning as the portfolio grows; the quantum representation stays well below it at every size.

n_assets	quantum kernel	classical kernel
8	0.45	0.54
12	0.60	0.82
16	0.69	0.99

At 16 assets the classical kernel is at chance (0.99 — it has stopped learning) while the quantum representation is still learning (0.69). The quantum error also rises with size: the task hardens as the portfolio grows, and the advantage is the persistent gap, not a flat curve. Absolute errors depend on the kernel bandwidth (these use the default setting); the robust statement is the comparison — the quantum representation stays below the classical kernel at every size, the gap widening with the portfolio.

Result — feature measurement on real hardware

The features are single-qubit measurements, readable on a real quantum processor (Huang, Kueng, Preskill 2020, arXiv:2002.08953). The reconstruction was validated on two vendors against an exact target.

state measured	qubits	exact reference	IQM Garnet (20q)	IBM Marrakesh (156q)
`Ry(θ)\|0⟩`	1	`[0.866, 0.000, -0.500]`	`[0.858, 0.012, -0.481]` (~2%)	`[0.847, -0.027, -0.453]` (~5%)
shallow entangled circuit	4	12 expectations (exact, partial trace)	agreement: mean 9.7%, max 25%	agreement: mean 2.2%, max 6.1%

Single-qubit features reconstruct to ~2–5% on both vendors. On the 4-qubit entangled state IBM Marrakesh holds ~2% while IQM Garnet rises to ~10% mean — the two-qubit entangling-gate noise shows on the smaller device. Full per-vendor measured vectors are in hardware_results.json.

Load

from datasets import load_dataset

ds = load_dataset("SiriusQuantum/quantum-finance-risk-benchmark")["train"]
X = ds["quantum_features"]   # the quantum representation
y = ds["label"]              # the systemic-risk observable
# compare a classical model on X vs on ds["inputs"]; filter by ds["n_assets"] for the scaling

A classical model trains directly on quantum_features. Reproducing the quantum kernel and the relabeling step requires the ReLab engine.

Reproducibility

recipe.json records the engine commit, seed, generator, and field definitions; every row regenerates deterministically. verification.json carries the sample-complexity result recomputed from the data.

Scope and limitations

The data is synthetic — a finance-structured Hamiltonian, not real market data. This is a benchmark of the quantum representation on a risk task, not a market, pricing, or trading claim.
The advantage is sample complexity, not a runtime speedup, and is demonstrated up to 16 assets.
A one-factor correlation model tends toward a mean-field (product) state as the portfolio grows; whether the advantage persists at large portfolio size, or is a finite-size effect, is open.
On real tabular financial data (credit scoring, payment fraud) classical kernels are competitive (Schuld, Bowles, et al. 2024, arXiv:2403.07059; Miyabe, Quanz, et al. 2023, arXiv:2312.00260).
Hardware results validate the feature-measurement path (to a 4-qubit entangled state), not a full learning curve measured on hardware.

References

Huang, Kueng, Preskill 2020 — arXiv:2002.08953 — classical shadows.
Huang, Broughton, Mohseni, et al. 2021 — arXiv:2011.01938 — projected quantum kernels; geometric difference.
Huang, Kueng, Torlai, Albert, Preskill 2022 — arXiv:2106.12627 (Science) — provably efficient ML for quantum many-body problems.
Lewis, Huang, Tran, et al. 2024 — Nat. Commun. 15:895, doi:10.1038/s41467-024-45014-7 — O(log n) sample complexity for ground-state properties.
Wanner, Lewis, Bhattacharyya, Dubhashi, Gheorghiu 2024 — arXiv:2405.18489 (NeurIPS) — constant sample complexity for predicting ground-state properties.
GLQK 2025 — arXiv:2509.13705 — geometrically-local quantum kernel; constant sample complexity for translationally-symmetric data.
Miyabe, Quanz, et al. 2023 — arXiv:2312.00260 — quantum kernels on financial classification.
Schuld, Bowles, et al. 2024 — arXiv:2403.07059 — classical baselines on out-of-the-box tasks.

Citation

If you use this dataset, please cite Sirius Quantum:

@misc{siriusquantum2026quantumfinancerisk,
  title        = {Quantum Finance Risk Benchmark},
  author       = {{Sirius Quantum}},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/SiriusQuantum/quantum-finance-risk-benchmark}}
}

Produced with the ReLab quantum data engine, Sirius Quantum — https://github.com/Sirius-Quantum