In this paper
AbstractModel DescriptionDynamic Observable ReconstructionResultsConclusionAcknowledgmentsReferencesSupplementary Material2D cylinder flow simulation detailsGray–Scott reaction–diffusion systemAutoencodersPressure-field observerQuantum reservoir network hyperparameter sweepClosed-loop rollouts and window comparisonsReadout hyperparameter sweepsPhysical layouts and compiled circuitsLatent tracesForecast horizons beyond one stepAdditional decoded-field comparisonsWorksPhysics and Astronomy
Realizing Unstructured PDE Forecasting on Superconducting Quantum Processors
Abstract
Simulating high dimensional unstructured Partial Differential Equations (PDEs) with quantum processors is a major challenge with significant potential benefit. Existing methods have been demonstrated at small qubit counts, on simplifications of realistic problems. We implement a quantum reservoir network (QRN) for forecasting high-dimensional unstructured PDEs using up to 52 qubits on IBM superconducting hardware. Our method is gradient-free and does not suffer from the challenges of variational quantum algorithms. Instead, the QRN provides a large kernel space, up to 2^52 dimensions and beyond the reach of exact classical simulation, that remains useful under current hardware noise levels. Furthermore, a partial measure-and-reset mechanism enables total circuit runtime for ~24 times the qubit coherence time, so qubit lifetimes do not limit the forecast horizon. Thus, our method enables forecasting realistic unstructured nonlinear PDEs on quantum hardware. Typical difficulties associated with predicting large scale PDEs, such as transpilation, exponential shot requirements, hardware noise, and short qubit lifetimes are mitigated through careful design considerations and a dynamic observable reconstruction method. We validate our approach using a ~34k cell unstructured 2D cylinder flow at Reynolds number 1000 and a challenging nonlinear Gray–Scott reaction–diffusion problem, demonstrating high fidelity prediction on CUDA-Q simulation and on 26 and 52-qubit superconducting quantum processors. Specifically, we show that adding QRN features to an autoencoder linear prediction pipeline reduces prediction error by 21%-43%. Finally, we demonstrate closed-loop autoregressive PDE forecasting on these problems. This work demonstrates, for the first time, quantum circuits with depth beyond qubit lifetimes achieving accurate unstructured mesh forecasting on highly nonlinear PDEs.
Simulating and forecasting Partial Differential Equations (PDEs) is an ongoing computational challenge that spans many scientific and engineering disciplines, ranging from fusion reactor development [1], weather prediction [2], chemical reaction modeling [3, 4], and aerodynamic calculations of innovative wing designs [5]. To reduce computational burden, at realistic scales these simulations leverage so-called unstructured discretization schemes, which are unstructured graphs of polyhedrons whose density varies spatially across the problem domain [6]. Despite this and many other methods to alleviate the computational burden [7, 8, 9], modern PDE simulations of interest are prohibitively expensive, even with the use of national-scale high performance computing infrastructure [10]. Among other specialty computing techniques, quantum processor-based methods have been proposed to remediate these computational bottlenecks. In particular, quantum methods for simulating PDEs have made marked progress in the last fifteen years, and have garnered attention along with the large and growing computational capabilities afforded by advancements in quantum computing hardware and algorithms. Quantum algorithms for PDEs have developed along three directions [11, 12]: first-principles solvers that encode the underlying governing equations [13, 14], quantum physics-informed neural networks (Q-PINNs) trained to satisfy them [15, 16], and data-driven models that learn the dynamics from trajectories [17, 18]. Each has so far been held back by differing combinations of problem structure, trainability, and hardware realizability.
First-principles methods reduce the discretized PDE to a quantum linear system [13, 19] or to Hamiltonian simulation [14, 20], and treat nonlinearity through Carleman [21], Koopman–von Neumann [22], or lattice-Boltzmann [23] embeddings. Their promised exponential speedups assume efficient state preparation and full-state readout, and shrink to polynomial once these costs are counted [24, 25]. For nonlinear flows, efficiency guarantees further require dissipation to outweigh nonlinearity [21, 26], leading to convergence results only on flows with low Reynolds number (the ratio of inertial to viscous forces) up to [27]. Their encodings also assume uniform grids, leaving unstructured meshes as an open problem [28, 29]. The most complete flow-past-a-cylinder demonstrations with these methods reach only –43 in classical emulation [30, 31]. Near-term variational versions [32, 33] not only keep these constraints, but add trainability limitations [34] and measurement overheads of shots per cost evaluation [35]. As a result, hardware runs have been limited to linear problems, or problems whose nonlinearity is evaluated classically, on at most about a thousand grid points with fewer than twenty gate-based qubits [36, 37, 38, 39].
Q-PINNs instead represent the solution as the measured output of a parameterized circuit trained on the PDE residual [15, 16, 40]. This removes the grid and has reached three-dimensional geometries [41], but despite their large Hilbert space, these models have shown mixed gains over classical PINNs [42, 43]. They also inherit the barren plateaus and measurement costs of variational training [34, 44], reported demonstrations remain in classical simulation [41, 45], and their scalability to large turbulent hardware-executed problems remains to be established.
Data-driven methods learn the dynamics from simulated or measured trajectories, usually in a compressed latent space. Most are also variational, including quantum neural operators [17, 46], quantum recurrent networks on autoencoder latents [18, 47], and quantum Koopman and prior models [48, 49, 50], and so typically share the training burden above. These models have reached turbulent and high-Reynolds-number data, including experimental bluff-body wakes and unstructured-mesh flows [47, 49, 51], but the closest demonstrations on quantum hardware use at most 10–15 qubits per circuit [48, 49, 50].
In contrast, quantum reservoir computing (QRC) methods are an underexplored example of data-driven methods that appear to be more scalable than both first-principles methods and Q-PINNs, while maintaining the ability to operate on compressed representations of unstructured meshes. They are non-variational by design, and thus are a departure from other data-driven methods. Crucially, the quantum circuit is fixed and only a classical linear readout is trained [52]. The exponentially large Hilbert space of the register serves as a rich nonlinear feature map, while all learning happens classically, so there are no quantum gradients to estimate and training reduces to linear regression. QRC therefore offers access to a kernel space that grows exponentially with qubit number, without the trainability problems of variational circuits.
QRC methods have been demonstrated on several hardware platforms [53, 54, 55]. Feedback-driven variants re-inject measured outputs [56, 57, 58], while recurrent variants instead use weak measurements and non-unital dynamics to enable a persistent fading memory in the internal quantum reservoir state [59, 60, 61]. A recent hardware demonstration of the feedback-driven variant [62] established that QRC can be effectively scaled to greater than 100 qubit processors and take advantage of this dimensionality for improved performance; such approaches are better suited however to static tasks, as the overhead of re-encoding previous inputs or outputs each step limits the complexity of PDEs that can practically be handled. In contrast, recurrent QRC exploiting partial measurements and resets on superconducting processors have demonstrated tunable fading memories matched to the problem of interest [63], and have been proven both in theory and experiment to operate entirely unconstrained by qubit lifetimes [61, 64].
QRC has been applied to chaotic and reduced-order fluid dynamics [64, 65, 66, 67, 68, 69], but only in noiseless simulation or on at most about a dozen hardware qubits, and, to our knowledge, never to PDE fields on an unstructured mesh.
In this manuscript, we build on recurrent QRC by introducing a scalable method for forecasting large unstructured PDEs. We go on to demonstrate the experimental effectiveness of our technique using up to 52 qubits on IBM superconducting hardware. In particular, we use a graph neural network (GNN) autoencoder to compress PDE fields on an unstructured mesh into a low-dimensional latent state, decoupling geometry and boundary conditions from the quantum model by construction. The latent state drives a quantum reservoir network (QRN) whose partial measure-and-reset mechanism keeps the per-step circuit depth constant while allowing for persistent memory beyond QPU times [61, 63, 64]. Sampled observables then feed a linear readout that predicts the latent state at later time steps. Because no circuit parameter is trained, the approach removes both the grid constraint of first-principles solvers and the training burden of variational solvers and Q-PINNs.
We further introduce a dynamic observable reconstruction method, which mitigates the exponential shot cost of reading out larger registers. It retains Pauli observables only up to a maximum weight, chosen to suit the prediction task and the available shot budget. Finally we introduce a closed-loop autoregressive prediction protocol, realizable on current hardware, that allows the network to forecast from its own predictions. Together, these allow us to forecast a 2D cylinder flow at on a 33,824-cell unstructured mesh and a nonlinear Gray–Scott reaction–diffusion system, both in CUDA-Q simulation and on 26- and 52-qubit IBM processors. Adding the QRN features to the same latent-space linear readout reduces one-step and observer prediction error by 21–43%, with circuits running for up to the median qubit and up to the median qubit . The central result is that this large quantum kernel space, run on noisy hardware and with no circuit training, still adds predictive value to the PDE forecast. To our knowledge, this is the first PDE forecast on an unstructured, body-fitted mesh performed on quantum hardware, and the first closed-loop autoregressive PDE rollout executed on a quantum processor.
Model Description
The end-to-end pipeline is shown in Figure 1(a). A pretrained graph autoencoder (GAE) encodes each PDE snapshot into a latent vector , which is embedded into a quantum circuit using a data reuploading block [70, 71, 72], which performs a nonlinear transform on the inputs into Hilbert space [73, 74]. After some evolution, measurements of the readout qubits are used to obtain a vector of observables , as detailed in § 0.1 A. Those observables are concatenated with the current latent state as a ResNet-style “skip” connection [75] to form the readout features . A regularized linear readout is then trained to predict the next latent state according to

Figure 1. QRN architecture, hardware predictions, and closed-loop rollout protocol. (a) End-to-end quantum–classical architecture. A graph autoencoder compresses PDE fields into latent states that drive the QRN, whose recurrent block acts on a memory register (rows ) and a readout register (rows ) in three stages. In the embedding stage, the latent state is re-uploaded times as rotations on the memory qubits, interleaved with controlled- gates. A partial-SWAP exchange of strength weakly entangles each memory qubit to its readout partner, and a measure-and-reset of the readout qubits then applies a back-action on the memory register, together forming a tunable amplitude-damping channel on the memory register. Thus, the reservoir forgets old inputs at a rate set by and can operate far beyond qubit coherence times. Sampled observables feed a trained linear readout to predict the next latent state, which is decoded into PDE fields. (b) Reference fields, hardware predictions, and residuals for 2D cylinder flow using 26 qubits, showing velocity magnitude from one-step forecasting (top) and pressure from observer prediction (bottom). (c) Corresponding comparisons for Gray–Scott species A (top) and B (bottom) using 52 qubits on IBM QPUs. (d) Closed-loop rollout using a sliding latent window of fixed length . Each predicted latent is appended and the oldest state is removed to form the input window for the next prediction.
where and are the learned weights and biases, so the observables provide features beyond the direct linear dependence on the current latent state. Finally, the predicted latent state is passed through the GAE decoder to reconstruct the predicted PDE field. Importantly, the GAE is trained completely independently of the QRN, and is only tasked with learning the forward and inverse mapping of unstructured PDE discretizations to latent space vectors. The QRN is tasked to forecast the latent space dynamics of each system, which we observe remain nonlinear dynamics as evidenced by the traces in Sec S9 and as reflected by the error of the linear baseline (Table I).
| Task | Method | Qubits | NRMSE | ||
| Cylinder one-step | Classical Linear | — | — | 0.121 | — |
| QRN, CUDA-Q | 26 | 4 | 0.069 | 42.8 | |
| QRN, IBM QPU | 26 | 2 | 0.081 | 33.2 | |
| Cylinder observer | Classical Linear | — | — | 0.374 | — |
| QRN, CUDA-Q | 26 | 4 | 0.223 | 40.3 | |
| QRN, IBM QPU | 26 | 2 | 0.295 | 21.2 | |
| Gray–Scott one-step | Classical Linear | — | — | 0.225 | — |
| QRN, CUDA-Q | 26 | 1 | 0.133 | 41.1 | |
| QRN, IBM QPU | 26 | 1 | 0.133 | 41.1 | |
| QRN, IBM QPU | 52 | 1 | 0.133 | 41.1 |
Table I. One-step forecasting and observer prediction errors. One-step targets are cylinder velocity or Gray–Scott species concentrations; the observer target is cylinder pressure at from velocity at . The linear baseline is the same ridge readout on the GAE latent state with the QRN features replaced by classical linear regression, . is the maximum retained Pauli weight (all nonidentity Pauli-Z strings of weight ). is the reduction in NRMSE relative to the baseline for the same task. IBM QPU results are from ibm_boston. Best result per task in bold.
Forecasting these latent dynamics requires the reservoir to have a fading memory, which the QRN implements with a non-unital map acting on two registers, denoted memory and readout. In each embedding layer, the memory qubits receive Euler-angle rotations parameterized by the current latent vector, followed by fixed-angle entangling gates along the memory register; repeating this layer forms the data-reuploading block. A memory-exchange layer of partial-SWAP gates with strength then couples each memory qubit to its readout partner, after which the readout register is measured and reset, exerting a purifying back-action on the memory register. Together these layers act as a controlled amplitude-damping channel on the memory register that, like the fading memory of classical echo-state networks, retains recent inputs while discarding older information at a rate set by [63]. These operations yield a memory register that continues computing far beyond qubit coherence times, allowing for QRNs with in principle arbitrary gate depths. Earlier QRNs demonstrated over the and times [64], and the present circuits reach up to and . Unlike feedback-based methods [56, 57, 58, 65, 76, 77, 78], which carry memory by re-injecting measurement outcomes into the reservoir, the QRN creates this memory without collapse of the memory register.
Dynamic Observable Reconstruction
Quantum measurements are fundamentally samples from a probability distribution, and in practice one must estimate observables from a finite number of shots, which imposes scaling challenges if not carefully managed [79]. At each time step, measurements of the readout qubits produce samples from a distribution over outcomes. Retaining only the single-qubit expectations is scalable, but discards the multi-qubit correlations generated by the entangling circuit. We therefore construct a tunable set of Pauli- observables from the measured bitstrings, interpolating between single-qubit features and a full set of observables representing the complete distribution.
Concretely, the circuit produces measurement bitstrings at each time-step . Let denote the number of times bitstring is observed. A subset specifies the support of a Pauli- string , where if and otherwise. The corresponding expectation value is estimated as
where is the Pauli weight of . These observables are joint moments of the measured binary variables, with the Pauli-weight specifying the moment order. Under independent symmetric readout errors with per-qubit bit-flip probability , weight- moments are attenuated by the factor , making higher-weight correlations harder to distinguish from sampling noise [80]. Retaining all strings through weight produces features. At , this yields nontrivial observables, matching the number of independent parameters in the -outcome probability distribution. The omitted identity observable has the fixed expectation , corresponding to normalization.
Together, this complete hierarchy forms the Walsh–Hadamard representation of the measured distribution [81]. Consequently, reconstructing the full -outcome distribution to total-variation error , with probability at least , requires
samples [82, 83]. Notably, this implies an exponential shot-scaling requirement as more qubits are measured, limiting
Results
feasibility with larger circuits. However, as our method is a form of QRC, every observable is calculated from the same measurement record, allowing for post-hoc selection of dependent upon shot-budget and hardware noise. Truncation of the retained subset allows for the factor in to be reduced to . Practically, the useful observable weight is only limited by finite sampling and by the sensitivity of higher-weight correlations to hardware noise [79, 80]. We report an ablation over differing Pauli weights on both hardware and simulators in Supp. Note S5 [84].
Experiments are conducted in simulation using CUDA-Q [85] and on IBM superconducting QPUs, using between 10,000 and 30,000 shots per circuit execution. Detailed shot budgets and experimental parameters are provided in Supp. Note S5 [84]. The datasets used are a 2D flow-past-a-circular-cylinder system at Reynolds number , generated using OpenFOAM on a 33,824-cell unstructured mesh, and the Gray–Scott reaction–diffusion system from The Well dataset [86] on a uniform grid. The cylinder dataset contains 300 snapshots of velocity and pressure fields exhibiting periodic vortex shedding, while the Gray–Scott dataset contains 1,001 snapshots of two interacting species exhibiting spiral-pattern dynamics. Both datasets are highly nonlinear, which is a major challenge for quantum methods [21, 87, 88]. As discussed in § 0.1, the GAE then encodes the data into latent representations and that data is fed through the QRN circuit to generate features used for each predictive task. Details on the dataset and implementation are included in the Supp. Note [84].
The QRN is evaluated on three prediction tasks. In one-step forecasting, the network receives the encoded dataset state at each time step and predicts , where horizon . The GAE decoder then converts into velocity fields for cylinder flow or species concentrations for Gray–Scott. In observer prediction, the cylinder velocity field at time is used to predict the pressure field at , without pressure supplied as input. In closed-loop forecasting, the network starts from an encoded dataset state and predicts 10 successive time steps, feeding each predicted latent state back as the next input. One-step and closed-loop forecasting are evaluated on both datasets, while observer prediction is restricted to cylinder flow. Results beyond horizon are provided in Supp. Note S10 [84].
Table I summarizes the one-step and observer prediction results. Adding the QRN features improves on a linear baseline operating on the same latent representation in every case, reducing normalized root mean square error (NRMSE) by approximately 21–43%. The baseline uses the same ridge readout with the QRN’s features removed, , so the improvement isolates the contribution of the QRN features in predicting the nonlinear latent dynamics. This baseline shows that the QRN features add predictive value, however establishing utility goes beyond the goals of this manuscript and would require an ablation against different classical architectures trained on the same latents. This improvement persists on IBM hardware, although cylinder-flow errors increase relative to noiseless CUDA-Q simulation. For Gray–Scott, the reported NRMSE remains unchanged across simulation and hardware. This result persisted with increasing qubit count and different Pauli weight , suggesting a plateau in predictive performance. Reconstruction accuracy also depends on the GAE’s ability to represent the underlying fields. Figure 1(b) and Figure 1(c) show representative hardware reconstructions for the one-step and observer tasks. The reported NRMSE comes from the best performing Pauli weight in each of the experiments. Higher order Pauli weights are more susceptible to hardware noise and are also bounded in fidelity by the number of shots recovered from the circuit, therefore higher values of provided better performance in noiseless CUDA-Q simulation, and lower values performed best on hardware. More detail on the Pauli weight selection is given in Supp. Note S5 [84].
Closed-loop rollouts are performed in both simulation and hardware as a proof-of-concept, and compared to a classical baseline common to closed-loop autoregressive forecasting called persistence [89]. The protocol shown in Figure 1(d) reinitializes the reservoir and replays a sliding window of latent states before each prediction, incorporating predicted states as the rollout proceeds. Here, denotes the readout features obtained after processing the window, including its final latent state as the skip connection. This replay washes out initial conditions and approximates the reservoir state obtained from the full input history. Replaying only the recent window avoids restarting from the beginning of the time series and required reservoir updates for an -step rollout, with circuit size and shot count held fixed. Figure 2 compares resulting autoregressive rollouts from the 2D cylinder data against their one-step closed-loop errors. The best performing circuit was the hardware rollout run with an extra layer of CRZ gates included, which is an additional form of noise. The simulated autoregressive rollouts were universally worse than hardware, and only improved with artificial noise injection during training. See the Supp. Note S7 [84] for Gray–Scott rollouts and details on model parameters. Surprisingly, rollout error decreases as noise increases, so rather than limiting the reservoir hardware noise appears to improve closed-loop forecasting. In this closed-loop setting, the increased noise is thought to regularize the training to make it less prone to overfitting [90]. The authors do note that the hardware and simulated runs for this experiment did not use the same circuit seed, but this does not explain the trend seen, as the simulated circuits universally perform better at one-step prediction but worse in the autoregressive rollouts.
Figure 2. One-step versus closed-loop error by noise level, on the shared 10-step 2D-cylinder window (targets 240–249). Solid bars are the 10-step closed-loop rollouts. Open bars apply the same learned readout to the recorded ground-truth-driven observables over the identical targets, the 10-step one-step counterpart. The hardware and simulated runs are not seed-matched, but this discrepancy does not explain the trend seen here, as the one-step performance of the simulated runs are universally higher. A 10-step persistence model gives the baseline performance.
Finally, Table II summarizes execution times on classical GPU-accelerated simulation with CUDA-Q, and on the ibm_boston quantum processor.
For the 26-qubit circuits, QPU execution is about 1,800–3,300 faster than exact CUDA-Q statevector sampling of the same circuits on a single H100 GPU. This gap is expected since each shot of a measure-and-reset circuit must be simulated as a separate trajectory. The 52-qubit circuits executed on hardware are beyond exact statevector simulation. This comparison is only between running the QRN on a QPU and simulating it classically. It is not a speed-up over classical PDE solvers, which would likely be both more accurate and faster on these problems. Whether QRN forecasts can scale to a point where they can be useful for warmstarting classical solvers remains open and is left to future work.
| Task | Qubits | QPU (s) | H100 (s) | Speed-up |
| Cylinder Flow | ||||
| one-step | 26 | 75 | 3300 | |
| closed-loop | 26 | 465 | 1800 | |
| Gray–Scott | ||||
| one-step | 26 | 264 | 3200 | |
| one-step | 52 | 222 | — | — |
| closed-loop | 52 | 320 | — | — |
Table II. Execution time per experiment for the QRN circuits, normalized to 30,000 shots. QPU entries are ibm_boston device execution times, excluding queueing. GPU entries are CUDA-Q exact statevector sampling of the same circuits on a single NVIDIA H100, with parallel shot jobs summed. Closed-loop rows are complete 10-step rollouts, whose steps execute strictly in sequence. The 52-qubit circuits are beyond exact statevector simulation (—).
Conclusion
In this letter, we realize unstructured nonlinear PDE forecasting with a recurrent QRN on IBM QPUs and in CUDA-Q simulation. A graph autoencoder compresses PDE fields on arbitrary meshes into latent vectors, and a fixed quantum circuit with partial measure-and-reset generates features for a readout that is classically regressed against the data, so no circuit parameter is trained. A dynamic observable reconstruction method lets the Pauli weight be chosen after measurement to match the shot budget and hardware noise, and a sliding-window protocol enables closed-loop autoregressive PDE forecasting on a QPU.
The central finding is that a very large, untrained quantum kernel space adds predictive value that survives hardware noise. Despite the reservoir evolving on a state space of up to dimensions (well-beyond the memory capacity of exact classical simulation) and on circuits of lengths up to , its features reduce one-step error by 21–43% relative to the classical architecture components alone. Noise degrades one-step accuracy only modestly and, in closed-loop rollouts, actually improves it, which is consistent with noise acting as a regularizer. While we again emphasize that this work makes no claim of practical advantage, which would require ablation studies against the best classical methods, it does present evidence that large, gradient-free quantum kernel spaces can remain useful in the presence of noise, and even benefit from it. These findings emphasize that recurrent QRC is a promising direction for further exploration.
Acknowledgments
Acknowledgments — We acknowledge helpful and motivating conversations with Ian Pegler at NVIDIA, which motivated the experiments on predicting pressure given velocity. We acknowledge the use of IBM Quantum Credits through the IBM Quantum Startups Program. This work used Bridges-2 at the Pittsburgh Supercomputing Center through allocation CIS260063 from the Advanced Cyberinfrastructure Coordination Ecosystem: Services & Support (ACCESS) program, supported by National Science Foundation Grants No. 2138259, No. 2138286, No. 2138307, No. 2137603, and No. 2138296. The author EC acknowledges support from the DoW SMART (Science, Mathematics, and Research for Transformation) Scholarship. The views expressed in this paper are those of the authors and do not reflect the official policy or position of the aforementioned parties.
Code availability — The code implementing the QRN model used in this Letter is available at https://github.com/econnerty/QRC-partial-SWAP.
Author Contributions — E.C. conducted experiments and helped design the architecture. E.N.E. suggested the application area, helped design the architecture, and provided feedback. J.E. provided data for the experiments. T.L.P. provided project and editorial feedback and helped interpret the results. G.A. helped with ideation and editorial feedback.
References
Supplementary Material
2D cylinder flow simulation details
Data for the 2D cylinder system is generated by solving the incompressible unsteady Reynolds-averaged Navier–Stokes (URANS) equations for the mean velocity and mean pressure ,
in which the Reynolds stresses are represented through the Boussinesq hypothesis by an eddy viscosity . Closure is provided by the – SST model [91, 92], which transports the turbulent kinetic energy and the specific dissipation rate ,
where is the turbulence production term, the SST blending function that recovers – near walls and – in the free stream, and the eddy viscosity carries the shear-stress limiter with strain-rate magnitude and second blending function . The model constants take their standard values according to the updates provided in [92]. The Reynolds number based on the cylinder diameter is .
The system is integrated with OpenFOAM v2512 via the finite-volume solver pisoFoam with two pressure-correction loops at a fixed time step of . Temporal discretization is first-order implicit (backward Euler). Spatial discretization is second order for gradient and Laplacian terms, the latter with explicit non-orthogonal correction matching the corrected surface-normal-gradient scheme, with blended first/second-order schemes for the divergence terms (linearUpwind for momentum, limitedLinear for the turbulence quantities).
The computational domain spans with the cylinder centered downstream of the inlet, meshed by snappyHexMesh into a hex-dominant grid of 33,824 cells (33,004 hexahedra, 72 prisms, and 748 polyhedra). The near-wall resolution is sufficient to dispense with wall functions for the turbulence variables: the maximum on the cylinder wall is approximately 0.048 throughout the simulation.
Boundary conditions are a uniform Dirichlet inlet [, , ] with zero-gradient pressure; a fixed-pressure outlet () with zero-gradient , , and ; zero-gradient top and bottom boundaries; and a no-slip cylinder wall (, ) with zero-gradient pressure. From this simulation, 300 snapshots of () are retained at 0.1 s intervals (every 100 solver steps) in the periodic vortex-shedding regime. The pressure field of the same simulation supplies the observer target of Supplementary Note S4.
Gray–Scott reaction–diffusion system
Gray–Scott data is obtained from the gray_scott_reaction_diffusion collection of The Well benchmark suite [86], and realizes the reaction–diffusion model of Gray and Scott in the form studied by Pearson [4]. Two chemical species with concentrations and evolve under the coupled reaction–diffusion equations
where is the Laplacian, and are the species diffusivities, is the rate at which is fed into the domain, and is the rate at which is removed. The cubic autocatalytic term implements the reaction , consuming and producing . The competition between this autocatalysis and the linear feed and kill terms generates the stiff, localized kinetics that make the system a complementary test to the advection-dominated cylinder flow.
The trajectory used here has diffusivities and on the periodic domain discretized at , with the spirals parameter set (, ; validation trajectory 3). The 1,001 retained snapshots span at intervals of 10 time units.
Autoencoders
tbl:S1 records the architectures used for the field autoencoders. Cylinder velocity drives the QRN using 13 latents; the separate 48 pressure latents are observer targets only. Gray–Scott uses a convolutional autoencoder with 26 latents. The decoded fields include both errors from the QRN inference and inherent autoencoder reconstruction error.
The 2D cylinder graph encoders use the solver’s owner–neighbor cell adjacency, so compression preserves the unstructured mesh connectivity. Their coordinate-conditioned decoders reconstruct fields at the original cell centres. The pressure encoder is trained separately, with an additional mesh-edge gradient loss to retain spatial pressure differences. For the uniform Gray–Scott grid, residual convolutional layers provide the spatial encoder and transposed convolutions reconstruct both species. The same trained decoders are used for one-step and closed-loop predictions. Different architectures were used as seen fit to improve reconstruction accuracy.
| 2D cyl. velocity Graph AE | 2D cyl. pressure Graph AE | Gray–Scott Conv. AE | |
| Input | on 33,824 mesh cells | on 33,824 mesh cells | on 128 × 128 grid |
| Encoder | 4 residual GraphSAGE layers | 3 residual GraphSAGE layers | 4 stride-2 conv. layers + residual blocks |
| Latent | (tanh) | (tanh) | (tanh) |
| Decoder | Coordinate MLP + 2 GraphSAGE layers | Coordinate MLP + 2 GraphSAGE layers | Transposed convolutions |
| Parameters | |||
| Test MSE | |||
| Split | 240 / 30 / 30 | 210 / 60 / 30 | 701 / 150 / 150 |
caption: TABLE S1. Autoencoder architectures. The cylinder encoders operate on the OpenFOAM owner–neighbour cell-adjacency graph, and their implicit decoders (Fourier-feature coordinate MLPs) reconstruct all cell centres. Global readout is attention + max pooling. The pressure autoencoder provides the 48-dimensional observer target of Supplementary Note S4. It is trained with an added mesh-edge pressure-gradient loss (weight 0.1) that penalizes mismatched pressure differences between neighbouring cells. Test MSE is on normalized fields, and Split is the random train/val/test snapshot partition (the pressure model uses a 70/20/10 shuffle, seed ).
:::
Pressure-field observer
The pressure field from the 2D cylinder data is predicted using an “observer” style inference model where only velocity fields are provided to the model, and the network is tasked with predicting pressure fields. The velocity-driven reservoir measurements are reused to predict 48 pressure latents at with the “skip-connection” described in the main manuscript. This additional experiment requires no additional quantum circuits executions since observables are re-used and is generally considered more difficult than a standard one-step inference task. Pressure and velocity errors use different target variances for normalization, so their NRMSE values should be interpreted relative to their respective baselines.
Table S2 gives the experiment details and the decoded fields are shown in Figure S1, Figure S2. Field NRMSE ranges over the 60 test frames are 0.028–0.152 (CUDA-Q) and 0.030–0.185 (IBM). Horizon dependence and pressure-latent traces appear in Notes S10 and S9.
| Name | Parameter | CUDA-Q | IBM QPU |
| Observable Order | 1–4 | 2 | |
| # of Observable Features | 1,092 | 91 | |
| Design Matrix Columns | 1,105 | 104 | |
| Target Dimension (pressure) | 48 | 48 | |
| # of Training Data Points | 119 | 119 | |
| # of Test Data Points | 60 | 60 | |
| # of Washout Points | 120 | 120 | |
| Readout (elastic net) | |||
| Elastic-Net Mixing | 0.1 | 0.1 |
Table S2. TABLE S2. 2D Cylinder Pressure-Observer Parameters. The reservoirs, shot budgets, and recorded observables are identical to the featured velocity runs (Table S3); only the readout differs. Predictions are clipped to [−1, 1]; the readout is selected on test RMSE over the standard 88-configuration grid.
Figure S1. CUDA-Q pressure observer: lowest- (top) and highest-residual (bottom) test frames, showing truth, prediction, and residual. Field NRMSE includes autoencoder error.
Figure S2. IBM pressure observer: highest-residual test frame, complementing the representative pressure reconstruction in the Letter. Field NRMSE includes autoencoder error.
Quantum reservoir network hyperparameter sweep
In this section, we examine the effects of amplitude-damping strength and the number of reuploading blocks detailed in Figure S3, as well as the maximum Pauli weight included in the readout features. These parameters control memory capacity, circuit depth, and the inclusion of higher-order correlations through Pauli weight, respectively. Table S3 records the various QRN configurations used in the main manuscript.

Figure S3. The gate-level QRN schematic. Input rotations and memory-register entangling blocks comprise the Embedding/Reuploading layer, which is repeated times. The hyperparameter controls the partial-SWAP exchange in the Memory Exchange layer. Afterwards, readout qubits are measured and then reset.
| System/platform | Qubits | Blocks | Shots | Seed | Readout | ||
| Cylinder/CUDA-Q | 26 | .75 | 3 | 4 | 30,000 | 123123 | EN |
| Cylinder/IBM | 26 | .75 | 2 | 2 | 30,000 | 27183 | Lasso |
| Gray–Scott/CUDA-Q | 26 | .75 | 3 | 1 | 10,000 | 14021 | Lasso |
| Gray–Scott/IBM | 26 | .75 | 3 | 1 | 30,000 | 14021 | Lasso |
| Gray–Scott/IBM | 52 | .9 | 2 | 1 | 30,000 | 27183 | Lasso |
Table S3. one-step reservoir and selected readout parameters. EN denotes elastic net; is the regularization strength and is the elastic-net mixing ratio. is the maximum Pauli weight included in the readout features. The 26 qubit Gray–Scott hardware run matches the simulation reservoir. IBM shot totals pool 3, 4, and 6 jobs for cylinder, 26 qubit Gray–Scott, and 52 qubit Gray–Scott, respectively.
To test whether higher Pauli-weight observables, and thus more observables, improve predictions, we provide an ablation over Pauli-weight in Figure S4. For 13 readout qubits, orders yield 13, 91, 377, and 1,092 features, respectively; for 26 readout qubits, they yield 26, 351, 2,951, and 17,901 features. Higher orders improve the noiseless cylinder predictions, whereas cylinder hardware reaches its minimum error at and then degrades, consistent with reduced usefulness of higher-order correlations under device noise. Gray–Scott accuracy changes little across orders at the executed shot budgets; whether additional shots would reveal a benefit remains unresolved as compute times ballooned rapidly for the larger time-series data, limiting shot count in simulation.
Figure S4. Pauli weight comparison for cylinder velocity (left), pressure observer (middle), and Gray–Scott (right). Readouts are reselected at each order using the same recorded counts. Stars mark the featured choices. Cylinder hardware achieves its minimum error at , while Gray–Scott changes little across orders. Lower is better.
Figure S5 details various QRN configurations that perturb damping parameter and the number of reuploading blocks. We observe stronger sensitivity in the 2D cylinder flow task than for Gray–Scott. Two reuploading blocks outperform three across the tested cylinder damping strengths, with the same reservoir selected for velocity and pressure prediction. Gray–Scott varies by only about 0.3% across the sweep.
Figure S5. Hardware reservoir sweep at seed 27183: test NRMSE versus amplitude-damping strength for two or three reuploading blocks. Panels show cylinder velocity, cylinder pressure, and Gray–Scott. Stars mark selected configurations; each point represents a single run with its best test-selected readout. The Gray–Scott vertical scale is expanded.
Closed-loop rollouts and window comparisons
We provide further detail on the autoregressive rollouts in this section. For each predicted step, a window is used to re-initialize the reservoir by replaying the current latent window. Only the final time-step of observables provide features to the learned readout. The prediction of the readout is then appended and the oldest latent removed. All rollouts use order-1 observables to limit noisy higher-order features being fed back. The 2D cylinder uses and targets 240–249; Gray–Scott uses and targets 501–510. All reported rollout metrics cover 10 steps.
The parameters for these experiments are given in Table S4. For the 52 qubit Gray–Scott rollout, a three reuploading block reservoir is trained and used in contrast to the two block circuit from the main manuscript, as it was observed to perform better.
| System/platform | Qubits | Shots | Seed | EN (, ) | NRMSE | ||
| Cylinder/CUDA-Q | 26 | .75 | 100 | 10,000 | 123123 | (, .1) | .707 |
| Cylinder/IBM | 26 | .75 | 100 | 20,000 | 14021 | (, .25) | .257 |
| Gray–Scott/IBM | 52 | .9 | 40 | 20,000 | 14021 | (, .5) | .470 |
Table S4. Featured closed-loop runs: three reuploading blocks, order-1 features, and 10 predictions throughout. Shots are per predicted latent vector. Persistence NRMSE is 1.126 for cylinder and 0.733 for Gray–Scott. The simulation uses a wrapped entangling ring; hardware uses an open chain.
Table S5 records an ablation over several window choice . A longer replay can reduce initialization effects, but the observed score also depends on the learned readout and on errors already fed back into the window. The selected cylinder deployment uses the longest tested window (), whereas Gray–Scott performs best here at . These comparisons do not identify a universal optimal window length. The final-step decoded fields are shown in Figure S6 and Figure S7; Note S9 resolves their evolution in latent space.
| System | Readout | NRMSE | |
| 2D cylinder | 20 | lasso, | 0.337 |
| 2D cylinder | 40 | ridge, | 0.402 |
| 2D cylinder | 45 | elastic net, | 0.402 |
| 2D cylinder | 100 | elastic net, | 0.318 |
| 2D cylinder | 100 | elastic net, | 0.257{sup}† |
| Gray–Scott | 20 | lasso, | 0.511 |
| Gray–Scott | 40 | ridge, | 0.470{sup}† |
| Gray–Scott | 45 | lasso, | 0.531 |
| Gray–Scott | 100 | lasso, | 0.534 |
Table S5. Executed hardware window comparisons, each evaluated over 10 targets. Readouts were selected separately, so this is not an isolated ablation of . Daggers identify the featured runs. The two cylinder entries share the readout and differ in the final-block CRZ layer; the featured entry retains it.
Figure S6. Decoded 2D Cylinder field from the final step of the hardware autoregressive rollout (truth / prediction / residual), for the 10-step velocity-magnitude forecast. The quoted NRMSE is computed against the original (pre-encoding) field and therefore includes the autoencoder reconstruction error.
Figure S7. Decoded Gray–Scott species (top) and (bottom) at the final step of the 52 qubit hardware autoregressive rollout (truth / prediction / residual). The quoted NRMSE is computed against the original (pre-encoding) field and therefore includes the autoencoder reconstruction error.
Notably, the featured cylinder hardware rollout of Figure 2 of the main manuscript retains the final-block CRZ layer omitted in training: its NRMSE is 0.257, versus 0.318 when that layer is omitted in rollout too. This increase in performance is thought to be due to the observation that increased training noise actually helps autoregressive rollout, but warrants further investigation. CUDA-Q and IBM cylinder rollouts differ in seed and shots, so the platform comparison is not a controlled noise ablation. The authors note that the differences in configurations cannot explain the performance difference alone, as the simulated circuits generally perform better in one-step forecasting but not in the autoregressive rollouts. The CUDA-Q noise-injection variants in the Letter refit the readout using eight Gaussian-noise replicas of the observable columns (), selecting ridge with .
Readout hyperparameter sweeps
Here, we provide results from an 88-configuration hyperparameter sweep comparing ridge, lasso, and elastic net across regularization strengths in Figure S8, Figure S9, Figure S10, Figure S11, Figure S12, Figure S13, and Figure S14. Each curve shows the family’s best test error at each ; the unregularized readout is a reference. Pressure sweeps appear in Note S4.
Figure S8. CUDA-Q 2D cylinder: readout hyperparameter sweep (88 configurations) for the velocity () task. The pressure-observer readout is swept separately (Supplementary Note S4). Lower is better.
Figure S9. CUDA-Q Gray–Scott: readout hyperparameter sweep for the species , () task. Lower is better.
Figure S10. IBM 2D cylinder: readout hyperparameter sweep for the velocity () task. Lower is better.
Figure S11. IBM Gray–Scott (26 qubits): readout hyperparameter sweep for the species , () task of the matched-reservoir hardware run (Table S3). Lower is better.
Figure S12. IBM Gray–Scott (52 qubits): readout hyperparameter sweep for the species , () task. Lower is better.
Figure S13. CUDA-Q 2D cylinder pressure-observer () task: readout hyperparameter sweep (88 configurations). Lower is better.
Figure S14. IBM 2D cylinder pressure-observer () task: readout hyperparameter sweep (88 configurations). Lower is better.
The IBM and CUDA-Q Gray–Scott forecasting readouts are selected on one-step test error. The CUDA-Q cylinder velocity readout instead follows mean test error over horizons , as in the original experiment; this is done to aid the autoregressive task in Figure 2 by optimizing error over a larger horizon. Pressure readouts are selected separately on one-step pressure test error.
Physical layouts and compiled circuits
We provide the layout and various configuration details for the circuits in the main manuscript in this section. Circuit layouts are shown in Figure S15 and are extracted from the transpiled training circuits. The compiled statistics distinguish full-trajectory one-step circuits from the autoregressive circuits executed for each rollout step. These details are provided in Table S6.
Figure S15. Compiled 26 and 52 qubit layouts on ibm_boston. Blue and orange mark initial memory and readout assignments; black edges show the chain. Routing can permute assignments within the footprint.
| System | Protocol | Qubits | Reuploading Blocks | Steps driven | Depth | Depth /step | CZ | CZ /step | 1q gates |
| 2D cylinder | 26 | 2 | 300 | 14,234 | 47.4 | 38,670 | 129 | 156,068 | |
| Gray–Scott | 26 | 3 | 1,001 | 99,670 | 99.6 | 211,921 | 212 | 837,891 | |
| Gray–Scott | 52 | 2 | 1,001 | 53,322 | 53.3 | 272,827 | 273 | 1,081,770 | |
| 2D cylinder | AR (per step) | 26 | 3 | 100 | 14,103 | 141.0 | 28,365 | 284 | 106,731 |
| Gray–Scott | AR (per step) | 52 | 3 | 40 | 4,466 | 111.7 | 18,253 | 456 | 69,965 |
Table S6. Compiled circuit statistics of the executed hardware experiments on ibm_boston, in the device ISA basis {CZ, RZ, SX, X}. The one-step () rows are the single circuits that drive the full trajectory. The autoregressive (AR) rows are one rollout step, which re-drives a window of time steps and is executed once per predicted latent vector. “Steps driven” is the number of recurrent time steps in the circuit, and the per-step columns are the totals divided by it. One-qubit gates are the RZ, SX, and X totals combined, and each driven step contributes one measurement and one reset per readout qubit.
Latent traces
Latent traces with ground truth and predicted outcomes are detailed in this section in Figure S16, Figure S17, Figure S18, Figure S19, and Figure S20. One-step () prediction traces cover cylinder targets 240–299 and Gray–Scott targets 501–1000. Closed-loop traces cover targets 240–249 and 501–510, respectively. Pressure traces show all 48 observer targets. Dashed CUDA-Q overlays are included where available.
Figure S16. IBM 2D cylinder, velocity task: latent traces on hardware (blue), with the noiseless CUDA-Q prediction overlaid (orange, dashed), against the ground truth (gray).

Figure S17. IBM Gray–Scott, species , task: latent traces (500-step test window) on hardware (blue), with the noiseless CUDA-Q prediction overlaid (orange, dashed), against the ground truth (gray).
Figure S18. IBM 2D cylinder, pressure-observer () task: all 48 pressure-latent traces over the test window (240–299), predicted from the hardware observables and velocity latents alone (blue; Supplementary Note S4), with the noiseless CUDA-Q prediction overlaid (orange, dashed), against the ground truth (gray).
Figure S19. Cylinder latent traces for the 10-step hardware rollout and noiseless CUDA-Q rollout, compared with truth (targets 240–249).

Figure S20. IBM Gray–Scott: per-latent traces of the featured 10-step autoregressive hardware rollout (targets 501–510).
These panels show how aggregate error is distributed across latent coordinates and time. In one-step tasks, each prediction receives the true current latent, so an error is not propagated through the input sequence. The closed-loop traces instead show the combined effects of prediction and feedback. The close one-step experiment platform agreement can therefore coexist with visibly different cylinder rollout trajectories.
Forecast horizons beyond one step
Here we present results detailing QRN prediction accuracy across different horizons . Figure S21 details IBM vs CUDA-Q performance on the 2D Cylinder tasks, and Figure S22 details the Gray–Scott tasks. A separate readout is used to map the features at to for each , without feeding predictions back. Linear baselines use the current latents alone.
Figure S21. Cylinder direct forecast NRMSE versus horizon for velocity and pressure: IBM and CUDA-Q against each task’s linear baseline. Each horizon has its own fitted readout; the supplied plots cover .
Figure S22. Gray–Scott direct forecast NRMSE versus horizon: 26 qubit CUDA-Q and 26/52 qubit IBM runs against the latent-linear baseline. All use order-1 observables. The 26 qubit hardware reservoir matches the simulation.
The cylinder velocity error increases with horizon, while the pressure observer is comparatively flat and can improve at later targets. Because pressure is inferred from velocity rather than extrapolated from its own past latent, its improved performance over larger horizons may indicate that pressure is a lagging indicator of velocity. For Gray–Scott, the curves remain close across the three platform/register choices over the shown horizons, consistent with the small Pauli weight gains in Figure S4.
Additional decoded-field comparisons
The following panels extend the representative reconstructions in the Letter with simulation results and highest-residual hardware frames. Each panel shows truth, prediction, and residual. Field NRMSE includes autoencoder error and is distinct from latent NRMSE.
Figure S23. CUDA-Q 2D cylinder, decoded fields (truth / prediction / residual): lowest-residual (top) and highest-residual (bottom) test frames. The quoted NRMSE is computed against the original (pre-encoding) field and therefore includes the autoencoder reconstruction error.
Figure S24. Cylinder velocity on IBM: highest-residual one-step test frame.
Figure S25. Gray–Scott species A on IBM (52 qubits): highest-residual one-step test frame.
Figure S26. Gray–Scott species on IBM (52 qubits): highest-residual one-step test frame.
References
- [1]mas: Current status and future direction, Plasma Science and Technology 9, 312 (2007).
- [2]P. Bauer, A. Thorpe, and G. Brunet, The quiet revolution of numerical weather prediction, Nature 525, 47 (2015).DOI
- [3]T. Lu and C. K. Law, Toward accommodating realistic fuel chemistry in large-scale computations, Progress in Energy and Combustion Science 35, 192 (2009).DOI
- [4]J. E. Pearson, Complex patterns in a simple system, Science 261, 189 (1993).DOI
- [5]P. R. Spalart and V. Venkatakrishnan, On the role and challenges of CFD in the aerospace industry, The Aeronautical Journal 120, 209 (2016).DOI
- [6]W. C. Skamarock, J. B. Klemp, M. G. Duda, L. D. Fowler, S.-H. Park, and T. D. Ringler, A multiscale nonhydrostatic atmospheric model using centroidal Voronoi tessellations and C-grid staggering, Monthly Weather Review 140, 3090 (2012).DOI
- [7]M. J. Berger and J. Oliger, Adaptive mesh refinement for hyperbolic partial differential equations, Journal of Computational Physics 53, 484 (1984).
- [8]P. Benner, S. Gugercin, and K. Willcox, A survey of projection-based model reduction methods for parametric dynamical systems, SIAM Review 57, 483 (2015).DOI
- [9]T. Pfaff, M. Fortunato, A. Sanchez-Gonzalez, and P. W. Battaglia, Learning mesh-based simulation with graph networks, in International Conference on Learning Representations (ICLR) (2021) arXiv:2010.03409.arxiv.org/abs/2010.03409
- [10]J. P. Slotnick, A. Khodadoust, J. Alonso, D. Darmofal, W. Gropp, E. Lurie, and D. J. Mavriplis, CFD vision 2030 study: A path to revolutionary computational aerosciences, NASA Contractor Report NASA/CR-2014-218178 (2014), nTRS 20140003093.
- [11]S. Succi, W. Itani, K. Sreenivasan, and R. Steijl, Quantum computing for fluids: Where do we stand?, EPL (Europhysics Letters) 144, 10001 (2023), arXiv:2307.05157.arxiv.org/abs/2307.05157
- [12]F. Tennie, S. Laizet, S. Lloyd, and L. Magri, Quantum computing for nonlinear differential equations and turbulence, Nature Reviews Physics 7, 220 (2025), arXiv:2406.04826.arxiv.org/abs/2406.04826
- [13]A. W. Harrow, A. Hassidim, and S. Lloyd, Quantum algorithm for linear systems of equations, Physical Review Letters 103, 150502 (2009), arXiv:0811.3171 [quant-ph].DOI
- [14]S. Jin, N. Liu, and Y. Yu, Quantum simulation of partial differential equations via Schrödingerization, Physical Review Letters 133, 230602 (2024), arXiv:2212.13969 [quant-ph].DOI
- [15]O. Kyriienko, A. E. Paine, and V. E. Elfving, Solving nonlinear differential equations with differentiable quantum circuits, Physical Review A 103, 052416 (2021), arXiv:2011.10395.DOI
- [16]S. Markidis, On physics-informed neural networks for quantum computers, Frontiers in Applied Mathematics and Statistics 8, 1036711 (2022), arXiv:2209.14754.DOI
- [17]N. Jain, J. Landman, N. Mathur, and I. Kerenidis, Quantum fourier networks for solving parametric pdes, Quantum Science and Technology 9, 035026 (2024).arxiv.org/abs/2306.15415
- [18]Y. Chen, A. Khaliq, and K. M. Furati, Quantum recurrent neural networks with encoder-decoder for time-dependent partial differential equations (2025), arXiv:2502.13370 [cs.LG].arxiv.org/abs/2502.13370
- [19]A. M. Childs, J.-P. Liu, and A. Ostrander, High-precision quantum algorithms for partial differential equations, Quantum 5, 574 (2021), arXiv:2002.07868 [quant-ph].DOI
- [20]D. An, J.-P. Liu, and L. Lin, Linear combination of hamiltonian simulation for nonunitary dynamics with optimal state preparation cost, Physical Review Letters 131, 150603 (2023).DOI
- [21]J.-P. Liu, H. Ø. Kolden, H. K. Krovi, N. F. Loureiro, K. Trivisa, and A. M. Childs, Efficient quantum algorithms for dissipative nonlinear differential equations, Proceedings of the National Academy of Sciences 118, e2026805118 (2021).DOI
- [22]I. Joseph, Koopman–von Neumann approach to quantum simulation of nonlinear classical dynamics, Physical Review Research 2, 043102 (2020), arXiv:2003.09980.
- [23]C. Sanavio and S. Succi, Lattice Boltzmann–Carleman quantum algorithm and circuit for fluid flows at moderate Reynolds number, AVS Quantum Science 6, 023802 (2024), arXiv:2310.17973.DOI
- [24]S. Aaronson, Read the fine print, Nature Physics 11, 291 (2015).DOI
- [25]N. Linden, A. Montanaro, and C. Shao, Quantum vs. classical algorithms for solving the heat equation, Communications in Mathematical Physics 395, 601 (2022), arXiv:2004.06516 [quant-ph].arxiv.org/abs/2004.06516
- [26]D. Lewis, S. Eidenbenz, B. Nadiga, and Y. Subaşı, Limitations for quantum algorithms to solve turbulent and chaotic systems, Quantum 8, 1509 (2024), arXiv:2307.09593 [quant-ph].DOI
- [27]D. Jennings, K. Korzekwa, M. Lostaglio, R. Ashworth, E. Marsili, and S. Rolston, End-to-end quantum algorithm for nonlinear fluid dynamics with bounded quantum advantage, PRX Quantum 7, 033060 (2026).DOI
- [28]M. Deiml and D. Peterseim, Quantum realization of the finite element method, Mathematics of Computation 95, 2637 (2026), arXiv:2403.19512.DOI
- [29]M. G. Cecile, N.-L. van Hülst, T. Hashizume, P. Siegl, A. Setty, J. D. d. C. Jesus, P. Over, S. Bengoetchea, M. Umer, S. Tserkis, E. Mastorakis, T. Kraft, F. Cárdenas-López, L. Scandurra, T. Rung, F. Motozi, B. Yesil, B. Kraus, M. Kiffner, D. G. Angelakis, E. de Villiers, and D. Jaksch, Quantum algorithms for computational fluid dynamics (2026), review article, preprint, arXiv:2609.39962.arxiv.org/abs/2609.39962
- [30]D. Jennings, K. Korzekwa, M. Lostaglio, P. Mannix, R. Ashworth, E. Marsili, and S. Rolston, Simulating non-trivial incompressible flows with a quantum lattice Boltzmann algorithm, in AIAA SCITECH 2026 Forum (American Institute of Aeronautics and Astronautics, 2026) arXiv:2512.05781 [quant-ph].DOI
- [31]H. Su, B. Wang, and Y. Yang, Quantum lattice Boltzmann method via density-matrix encoding for fluid simulation with wall boundary conditions (2026), arXiv:2609.06179 [quant-ph].arxiv.org/abs/2609.06179
- [32]C. Bravo-Prieto, R. LaRose, M. Cerezo, Y. Subaşı, L. Cincio, and P. J. Coles, Variational quantum linear solver, Quantum 7, 1188 (2023), arXiv:1909.05820.
- [33]M. Lubasch, J. Joo, P. Moinier, M. Kiffner, and D. Jaksch, Variational quantum algorithms for nonlinear problems, Physical Review A 101, 010301 (2020), arXiv:1907.09032.DOI
- [34]M. Larocca, S. Thanaslip, S. Wang, K. Sharma, J. Biamonte, P. J. Coles, L. Cincio, J. R. McClean, Z. Holmes, and M. Cerezo, Barren plateaus in variational quantum computing, Nature Reviews Physics 7, 174 (2025), arXiv:2405.00781.DOI
- [35]A. Sarma, T. W. Watts, M. Moosa, Y. Liu, and P. L. McMahon, Quantum variational solving of nonlinear and multidimensional partial differential equations, Phys. Rev. A 109, 062616 (2024).DOI
- [36]M. Ali and M. Kabel, Performance study of variational quantum algorithms for solving the Poisson equation on a quantum computer, Phys. Rev. Appl. 20, 014054 (2023).DOI
- [37]Z. Song, R. Deaton, B. Gard, and S. H. Bryngelson, Incompressible navier–stokes solve on noisy quantum hardware via a hybrid quantum–classical scheme, Computers & Fluids 288, 106507 (2025).DOI
- [38]Z. Meng, J. Zhong, S. Xu, K. Wang, J. Chen, F. Jin, X. Zhu, Y. Gao, Y. Wu, C. Zhang, N. Wang, Y. Zou, A. Zhang, Z. Cui, F. Shen, Z. Bao, Z. Zhu, Z. Tan, T. Li, P. Zhang, S. Xiong, H. Li, Q. Guo, Z. Wang, C. Song, H. Wang, and Y. Yang, Simulating unsteady flows on a superconducting quantum processor, Communications Physics 7, 349 (2024), arXiv:2404.15878.DOI
- [39]A. Bastida-Zamora, L. Budinski, O. Kerppo, V. Lahtinen, O. Niemimäki, W. Steadman, R. Zamora-Zamora, P. Sagaut, V. Bohun, M. Koch-Janusz, and I. Lukin, Quantum algorithm for the lattice Boltzmann method with applications on real quantum devices (2026), arXiv:2603.02127.
- [40]C. Trahan, M. Loveland, and S. Dent, Quantum physics-informed neural networks, Entropy 26, 649 (2024).DOI
- [41]A. Sedykh, M. Podapaka, A. Sagingalieva, K. Pinto, M. Pflitsch, and A. Melnikov, Hybrid quantum physics-informed neural networks for simulating computational fluid dynamics in complex shapes, Machine Learning: Science and Technology 5, 025045 (2024), arXiv:2304.11247.DOI
- [42]A. Farea, S. Khan, and M. Serdar Celebi, Qpinn: quantum-classical physics-informed neural networks for solving pdes, Machine Learning: Science and Technology 6, 045053 (2025).
- [43]S. Berger, N. Hosters, and M. Möller, Trainable embedding quantum physics informed neural networks for solving nonlinear pdes, Scientific reports 15, 18823 (2025).DOI
- [44]J. R. McClean, S. Boixo, V. N. Smelyanskiy, R. Babbush, and H. Neven, Barren plateaus in quantum neural network training landscapes, Nature Communications 9, 4812 (2018).DOI
- [45]F. Y. Leong, W. B. Ewe, S. B. Q. Tran, Z. Zhang, and J. Y. Khoo, Hybrid quantum physics-informed neural network: Towards efficient learning of high-speed flows, Computers & Fluids 301, 106782 (2025).arxiv.org/abs/2503.02202
- [46]P. Xiao, M. Zheng, A. Jiao, X. Yang, and L. Lu, Quantum DeepOPNet: Neural operators accelerated by quantum computing, Quantum 9, 1761 (2025), arXiv:2409.15683.DOI
- [47]M. Takagi, R. Kokubo, M. Kurosawa, T. Ikami, Y. Egami, H. Nagai, T. Kashikawa, K. Kimura, Y. Takita, and Y. Matsuda, Time-series forecasting for nonlinear high-dimensional system using hybrid method combining autoencoder and multi-parallelized quantum long short-term memory and gated recurrent unit (2025), arXiv:2507.10876 [quant-ph].arxiv.org/abs/2507.10876
- [48]B. Zhang, D. An, Z. Meng, Y. Yu, X. Xiao, Z. Lu, and Y. Yang, Quantum simulation of real-world nonlinear dynamics via Koopman method (2026), arXiv:2607.07338.arxiv.org/abs/2607.07338
- [49]M. Wang, X. Xue, M. Gao, and P. V. Coveney, Quantum-informed machine learning for predicting spatiotemporal chaos with practical quantum advantage, Science Advances 12, eaec5049 (2026), arXiv:2507.19861.DOI
- [50]X. Xue, M. Wang, M. Gao, M. Chung, and P. V. Coveney, Explainable quantum-compressed machine learning for complex fluid flows (2026), arXiv:2607.21688.arxiv.org/abs/2607.21688
- [51]H. Li, Y. Lou, and D. Xiao, Quantum machine learning for efficient reduced order modelling of turbulent flows (2025), arXiv:2511.18552.arxiv.org/abs/2511.18552
- [52]P. Mujal, R. Martínez-Peña, J. Nokkala, J. García-Beni, G. L. Giorgi, M. C. Soriano, and R. Zambrini, Opportunities in Quantum Reservoir Computing and Extreme Learning Machines, Advanced Quantum Technologies 4, 2100027 (2021).DOI
- [53]J. Chen, H. I. Nurdin, and N. Yamamoto, Temporal information processing on noisy quantum computers, Phys. Rev. Appl. 14, 024065 (2020).DOI
- [54]M. Kornjača, H.-Y. Hu, C. Zhao, J. Wurtz, P. Weinberg, M. Hamdan, A. Zhdanov, S. H. Cantu, H. Zhou, R. A. Bravo, K. Bagnall, J. I. Basham, J. Campo, A. Choukri, R. DeAngelo, P. Frederick, D. Haines, J. Hammett, N. Hsu, M.-G. Hu, F. Huber, P. N. Jepsen, N. Jia, T. Karolyshyn, M. Kwon, J. Long, J. Lopatin, A. Lukin, T. Macrì, O. Marković, L. A. Martínez-Martínez, X. Meng, E. Ostroumov, D. Paquette, J. Robinson, P. S. Rodriguez, A. Singh, N. Sinha, H. Thoreen, N. Wan, D. Waxman-Lenz, T. Wong, K.-H. Wu, P. L. S. Lopes, Y. Boger, N. Gemelke, T. Kitagawa, A. Keesling, X. Gao, A. Bylinskii, S. F. Yelin, F. Liu, and S.-T. Wang, Large-scale quantum reservoir learning with an analog quantum computer (2024), arXiv:2407.02553 [quant-ph].arxiv.org/abs/2407.02553
- [55]T. Krisnanda, P. Song, A. Copetudo, C. Y. Fontaine, T. Paterek, T. C. H. Liew, and Y. Y. Gao, Experimental demonstration of enhanced quantum tomography via quantum reservoir processing, Quantum Science and Technology 10, 035041 (2025).DOI
- [56]K. Kobayashi, K. Fujii, and N. Yamamoto, Feedback-driven quantum reservoir computing for time-series analysis, PRX Quantum 5, 040325 (2024).DOI
- [57]J. Murauer, R. Krishnakumar, S. Tornow, and M. Geierhos, Feedback connections in quantum reservoir computing with mid-circuit measurements, in 2025 IEEE International Conference on Quantum Computing and Engineering (QCE) (IEEE, 2025) pp. 1646–1652.DOI
- [58]T. Monomi, W. Setoyama, and Y. Hasegawa, Feedback-enhanced quantum reservoir computing with weak measurements (2025), arXiv:2503.17939 [quant-ph].arxiv.org/abs/2503.17939
- [59]T. Yasuda, Y. Suzuki, T. Kubota, K. Nakajima, Q. Gao, W. Zhang, S. Shimono, A. Matsuo, J. Ananthanarayanan, H. I. Nurdin, and N. Yamamoto, Quantum reservoir computing with repeated measurements on superconducting devices (2023), arXiv:2310.06706 [quant-ph].arxiv.org/abs/2310.06706
- [60]P. Mujal, R. Martínez-Peña, G. L. Giorgi, M. C. Soriano, and R. Zambrini, Time-series quantum reservoir computing with weak and projective measurements, npj Quantum Information 9, 16 (2023).DOI
- [61]F. Hu, S. A. Khan, N. T. Bron, G. Angelatos, G. E. Rowlands, G. J. Ribeill, and H. E. Türeci, Overcoming the coherence time barrier in quantum machine learning on temporal data, Nature Communications 15, 7491 (2024).DOI
- [62]T. Dao, E. Yılmaz, I. Shehzad, C. Pere, K. Ghosh, I. Wittmann, T. Brunschweiler, G. Cortiana, C. O’Meara, S. Woerner, and F. Tacchino, Breaking concentration barriers for quantum extreme learning on digital quantum processors (2026).arxiv.org/abs/2603.13005
- [63]E. L. Connerty and E. N. Evans, Controllable quantum memory capacity in quantum reservoir networks with tunable partial-SWAPs (2026), arXiv:2605.12713 [quant-ph].arxiv.org/abs/2605.12713
- [64]E. L. Connerty, E. N. Evans, G. Angelatos, and V. Narayanan, Predicting chaotic dynamics on NISQ hardware with quantum reservoir networks, Communications Physics 9, 268 (2026).DOI
- [65]P. Pfeffer, F. Heyder, and J. Schumacher, Hybrid quantum-classical reservoir computing of thermal convection flow, Phys. Rev. Res. 4, 033176 (2022).DOI
- [66]P. Pfeffer, F. Heyder, and J. Schumacher, Reduced-order modeling of two-dimensional turbulent Rayleigh–Bénard flow by hybrid quantum-classical reservoir computing, Physical Review Research 5, 043242 (2023), arXiv:2307.03053.DOI
- [67]O. Ahmed, F. Tennie, and L. Magri, Prediction of chaotic dynamics and extreme events: A recurrence-free quantum reservoir computing approach, Physical Review Research 6, 043082 (2024).arxiv.org/abs/2405.03390
- [68]L. Salatino, L. Mariani, A. Giordano, F. D’Amore, C. Mastroianni, L. Pontieri, A. Vinci, C. Gencarelli, L. Primavera, F. Plastina, J. Settino, and F. Carbone, Forecasting low-dimensional turbulence via multi-dimensional hybrid quantum reservoir computing, Chaos: An Interdisciplinary Journal of Nonlinear Science 36, 083110 (2026).
- [69]E. L. Connerty, M. LaBorde, N. Evans, Leveraging metrologically useful states in quantum reservoir networks (2026), arXiv:2607.06500 [quant-ph].arxiv.org/abs/2607.06500
- [70]A. Pérez-Salinas, A. Cervera-Lierta, E. Gil-Fuster, and J. J. Latorre, Data re-uploading for a universal quantum classifier, Quantum 4, 226 (2020).
- [71]M. Schuld, R. Sweke, and J. J. Meyer, Effect of data encoding on the expressive power of variational quantum-machine-learning models, Physical Review A 103, 032430 (2021).DOI
- [72]W. Xiong, G. Facelli, M. Sahebi, O. Agnel, T. Chotibut, S. Thanasilp, and Z. Holmes, On fundamental aspects of quantum extreme learning machines, Quantum Machine Intelligence 7, 20 (2025).DOI
- [73]L. C. G. Govia, G. J. Ribeill, G. E. Rowlands, and T. A. Ohki, Nonlinear input transformations are ubiquitous in quantum reservoir computing, Neuromorphic Computing and Engineering 2, 014008 (2022).arxiv.org/abs/2107.00147
- [74]N.-E. Schütte, N. Götting, H. Müntinga, M. List, D. Brunner, and C. Gies, Expressivity of quantum reservoir computers (2025), arXiv:2501.15528 [quant-ph].arxiv.org/abs/2501.15528
- [75]K. He, X. Zhang, S. Ren, and J. Sun, Deep residual learning for image recognition, in Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR) (2016) pp. 770–778.
- [76]L. Gonon, R. Martínez-Peña, and J.-P. Ortega, Feedback-driven recurrent quantum neural network universality, in International Conference on Learning Representations, Vol. 2026 (2026) pp. 98886–98913.arxiv.org/abs/2506.16332
- [77]C. Zhu, P. J. Ehlers, H. I. Nurdin, and D. Soh, Minimalistic and scalable quantum reservoir computing enhanced with feedback, npj Quantum Information 11, 195 (2025).arxiv.org/abs/2412.17817
- [78]I. Paparelle, J. Henaff, J. García-Bení, É. Gillet, D. Montesinos, G. L. Giorgi, M. C. Soriano, R. Zambrini, and V. Parigi, Experimental memory control in continuous-variable optical quantum reservoir computing, Nat. Photonics 20, 413 (2026).DOI
- [79]F. Hu, G. Angelatos, S. A. Khan, M. Vives, E. Türeci, L. Bello, G. E. Rowlands, G. J. Ribeill, and H. E. Türeci, Tackling Sampling Noise in Physical Systems for Machine Learning Applications: Fundamental Limits and Egitanks, Physical Review X 13, 041020 (2023).DOI
- [80]E. van den Berg, Z. K. Minev, and K. Temme, Model-free readout-error mitigation for quantum expectation values, Phys. Rev. A 105, 032620 (2022).DOI
- [81]R. O’Donnell, Analysis of Boolean functions (2021), arXiv:2105.10386 [cs.DM].arxiv.org/abs/2105.10386
- [82]C. L. Canonne, A short note on learning discrete distributions (2020), arXiv:2002.11457 [math.ST].arxiv.org/abs/2002.11457
- [83]L. Devroye and G. Lugosi, Combinatorial Methods in Density Estimation, Springer Series in Statistics (Springer, New York, NY, 2001).DOI
- [84]See Supplemental Material appended to this manuscript for governing equations, numerical configurations, GAE training details, QRN implementation details, and additional results.
- [85]J.-S. Kim, A. McCaskey, B. Heim, M. Modani, S. Stanwyck, and T. B. Costa, CUDA quantum: The platform for integrated quantum-classical computing, in 2023 60th ACM/IEEE Design Automation Conference (DAC) (IEEE, 2023) pp. 1–4.DOI
- [86]R. Ohana, M. McCabe, L. Meyer, R. Morel, F. J. Agocs, M. Benitez, M. Berger, B. Burkhart, S. B. Dalziel, D. B. Fielding, D. Fortunato, J. A. Goldberg, K. Hirashima, Y.-F. Jiang, R. Kerswell, S. Maddu, J. Miller, P. Mukhopadhyay, S. S. Nixon, J. Shen, R. Watteaux, B. R.-S. Blancard, F. Rozet, L. Parker, M. Cranmer, and S. Ho, The well: a large-scale collection of diverse physics simulations for machine learning, in Advances in Neural Information Processing Systems, Vol. 37, edited by A. Globerson, L. Mackey, D. Belgrave, A. Fan, U. Paquet, J. Tomczak, and C. Zhang (Curran Associates, Inc., 2024) pp. 44989–45037.arxiv.org/abs/2412.00568
- [87]D. Jennings, K. Korzekwa, M. Lostaglio, A. T. Sornborger, Y. Subasi, and G. Wang, Quantum algorithms for general nonlinear dynamics based on the Carleman embedding, Quantum 10, 2233 (2026).DOI
- [88]J. Gonzalez-Conde, D. Lewis, S. S. Bharadwaj, and M. Sanz, Quantum carleman linearization efficiency in nonlinear fluid dynamics, Physical Review Research 7, 023254 (2025).
- [89]S. Rasp, P. D. Dueben, S. Scher, J. A. Weyn, S. Mouatadid, and N. Thuerey, WeatherBench: A benchmark data set for data-driven weather forecasting, Journal of Advances in Modeling Earth Systems 12, e2020MS002023 (2020).
- [90]M. Pasini, J. Nistal, S. Lattner, and G. Fazekas, Continuous autoregressive models with noise augmentation avoid error accumulation (2024), arXiv:2411.18447 [cs.LG].arxiv.org/abs/2411.18447
- [91]F. R. Menter, Two-equation eddy-viscosity turbulence models for engineering applications, AIAA Journal 32, 1598 (1994).DOI
- [92]F. R. Menter, M. Kuntz, and R. Langtry, Ten years of industrial experience with the SST turbulence model, in Turbulence, Heat and Mass Transfer 4: Proceedings of the Fourth International Symposium on Turbulence, Heat and Mass Transfer, edited by K. Hanijalić, Y. Nagano, and M. Tummers (Begell House, 2003) pp. 625–632.























