⚛️ quantum physics

A Scalable Approach to Solve the Carleman Linearized Burgers' Equation on a Quantum Computer

This paper presents a scalable quantum methodology for solving the Carleman linearized Burgers' equation by combining the linear combination of non-unitaries for state loading, a multigridding variational quantum linear solver to overcome barren plateaus, and successful demonstrations on real and simulated hardware that support circuits representing up to $2^{80}$ discretization points.

Original authors: Reuben Demirdjian, Yvan Quinn, Vincent P. Su, Hrant Gharibyan, Hayk Tepanyan

Published 2026-07-13

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Reuben Demirdjian, Yvan Quinn, Vincent P. Su, Hrant Gharibyan, Hayk Tepanyan

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine trying to teach a robot to predict how a drop of ink swirls and mixes in a glass of water. The problem? The robot is built to follow strict, straight-line rules (it's a "linear" machine), but swirling ink follows messy, curvy, unpredictable rules (it's "nonlinear"). It's like trying to teach a dog to do calculus by only showing it how to fetch a stick.

That's the big hurdle scientists face when trying to use quantum computers to simulate fluid dynamics. But in this study, researchers from the U.S. Naval Research Laboratory and BlueQubit Inc. found a clever workaround to get the robot to understand the swirl. They didn't try to force the robot to do the messy math directly; instead, they used a trick called Carleman linearization.

Think of this trick like translating a complex, chaotic story into a giant, boring spreadsheet. By expanding the story, they turned the messy, curvy equations of the Burgers' equation (a famous model for fluid flow) into a massive, straight-line system of equations. Once the problem was on the spreadsheet, they could use existing quantum tools designed for straight lines to solve it.

The "Loading" Problem and the Magic Key
The first challenge was getting this giant spreadsheet onto the quantum computer. Usually, loading a massive amount of data takes forever, like trying to upload a whole library to a phone in one second. The team used a new method called the Linear Combination of Non-Unitaries (LCNU).

Imagine you have a locked box (the data) and a set of keys. Old methods tried to make a master key out of a million tiny pieces, which was slow and clumsy. The new LCNU method is like having a few special, slightly weird keys (non-unitaries) that can be easily turned into perfect keys with just one extra helper (an extra qubit). This allowed them to load the data efficiently, regardless of how big the grid of fluid points got.

The "Barren Plateau" Trap and the Warm Start
Once the data was loaded, they needed to solve the equations using a method called the Variational Quantum Linear Solver (VQLS). But here's the catch: if you just start guessing the answer randomly, the computer gets lost in a vast, flat desert called a "barren plateau." It's like trying to find the bottom of a giant, flat bowl in the dark; you can walk for miles and never know if you're getting closer to the solution.

To fix this, the team used a multigridding strategy. Instead of starting with the full, high-definition puzzle, they started with a tiny, blurry version (a coarse grid). They solved that, then used that answer as a "warm start" (a helpful hint) to solve a slightly bigger version, and then an even bigger one. It's like learning to ride a bike: you start with training wheels, then a small bike, then a big one. By the time they reached the full resolution, the computer wasn't lost in the desert; it was already on the right path.

The Results: Simulations and Real Hardware
The team tested this workflow in two ways:

Simulations: They ran the whole process on a powerful computer simulator. They found that the "warm start" multigridding method was a game-changer. A naive, random start only got the answer about 1% accurate (converging to $10^{-2}$ ), but the multigridding method got it down to 0.1% accurate ( $10^{-3}$ ). The fluid waves didn't just fade away; they actually moved and behaved like real water.
Real Hardware: They then ran a smaller version of the problem on actual quantum computers from IBM (specifically the Heron r3 and Nighthawk processors). Even with the noisy, glitchy nature of today's machines, they managed to get a solution. They used a smart way to distribute their "shots" (the number of times they ran the experiment) so that the most important parts of the math got more attention. The results showed that while the machines made some errors, the method still worked, with the ibm_boston processor performing the best.

Looking Ahead: Is the Future Bright?
The researchers didn't just stop at the current results; they did a "resource estimation" to see if this could work for huge, real-world problems in the future. They crunched the numbers for quantum computers with up to $2^{40}$ (about 1024) combined spatial and temporal points.

Their calculations suggest that with future hardware that is less noisy and faster, this approach could actually run faster than classical supercomputers for these types of problems. They estimate that on future IBM processors, it might take only about $10^2$ hours (a few days) to reach a point of "quantum advantage," where the quantum computer beats the best classical methods.

However, the paper is careful to note that this is a proof of concept and a suggestion for the future, not a finished product. There are still big hurdles:

Noise: Today's quantum computers are still too noisy for the biggest problems.
Truncation: They used a minimum "truncation order" of $\alpha = 2$ . While this worked for their test, more complex, turbulent flows might need a higher order, which would make the system exponentially larger and harder to solve.
Conditioning: The math behind the scenes can be "ill-conditioned," meaning tiny errors can blow up into huge mistakes, requiring special "preconditioning" techniques that are still being developed.

In short, the team has built a working prototype of a bridge between the messy world of fluids and the straight-line world of quantum computers. They've shown it's possible to cross the river, but the bridge is still under construction, and they need better materials (less noisy hardware) to handle the heavy traffic of real-world storms.

Technical Summary: A Scalable Approach to Solve the Carleman Linearized Burgers' Equation on a Quantum Computer

Problem Statement
Simulating fluid dynamics on quantum computers presents a fundamental challenge: quantum computers are inherently linear machines, whereas fluid dynamics are governed by nonlinear partial differential equations (PDEs), such as the Burgers' equation. To bridge this gap, the Carleman linearization method is employed to transform finite-dimensional nonlinear ordinary differential equations (ODEs) into infinite-dimensional linear ODEs, which are subsequently truncated to form finite linear systems. However, solving these systems on quantum hardware faces two primary obstacles:

Data Loading Efficiency: The resulting linear system matrices scale exponentially with the number of spatial and temporal discretization points. Efficiently loading these matrices onto quantum hardware using only polylogarithmic classical resources is non-trivial, particularly when standard Linear Combination of Unitaries (LCU) approaches suffer from poor scaling.
Optimization Barriers: Variational Quantum Linear Solvers (VQLS), while capable of handling large systems, are prone to the "barren plateau" phenomenon, where gradient-based optimization fails to converge due to exponentially large search spaces and random initialization.

Methodology
The authors propose a comprehensive workflow to address these challenges, demonstrated on the 1D Burgers' equation with periodic boundary conditions.

Linearization and Zero-Padding: The Burgers' equation is discretized and transformed via Carleman linearization into a linear system $L\vec{Y} = \vec{B}$ . To facilitate efficient decomposition, the authors employ a zero-padding strategy, embedding the system into a larger dimensional space. This allows the matrix to be decomposed into a linear combination of specific non-unitary matrices that can be trivially encoded into unitary matrices with minimal overhead.
Efficient Data Loading (LCNU): Instead of the standard LCU approach, the study utilizes the Linear Combination of Non-Unitaries (LCNU). The authors derive a decomposition for the Carleman linearized matrix where the number of terms is independent of the spatial and temporal discretization points. Specifically, the matrix is decomposed into $N_s = \frac{1}{2}(9\alpha^2 + \alpha + 8)$ terms, where $\alpha$ is the truncation order. This decomposition relies on incrementer/decrementer circuits and specific Pauli operator structures, ensuring the data loading strategy scales polylogarithmically.
Variational Solver with Multigridding: The linear system is solved using the Variational Quantum Linear Solver (VQLS). To mitigate the barren plateau problem, a multigridding strategy is introduced. The problem is solved in a series of stages, starting with coarse spatial and temporal discretizations. The solution (variational parameters) from a coarser stage is used as a "warm start" for the next finer stage. This systematic initialization significantly improves convergence rates compared to naive random initialization.
Shot Allocation: An efficient shot allocation method is developed to distribute a fixed total number of shots among the various circuits required for the cost function evaluation. By minimizing the variance of the cost function, more shots are allocated to terms with larger coefficients, optimizing accuracy for the most significant contributions.

Key Contributions
The paper outlines five primary contributions:

Improved Data Loading: A strategy for the 1D Carleman linearized Burgers' equation where the number of terms in the LCNU decomposition is independent of the discretization grid size.
Multigridding Strategy: A spatial and temporal multigridding approach for the Carleman linearized system that provides systematic warm starts to avoid barren plateaus.
Shot Allocation: A method to distribute shots based on coefficient magnitudes to maximize accuracy for a fixed computational budget.
Proof of Concept: Demonstration of the workflow on both quantum simulators and real quantum hardware (IBM Heron r3 and Nighthawk processors).
Resource Estimation: A feasibility study transpiling circuits up to $2^{40}$ combined spatial and temporal points, suggesting that the methodology scales efficiently for future hardware.

Results

Simulation: On a quantum simulator, the multigridding approach converged the cost function to approximately $10^{-3}$ , whereas a naive approach with random initialization only reached $10^{-2}$ . The multigridding solution successfully captured essential physics (wave dampening and nonlinear advection), while the naive solution exhibited excessive damping and failed to capture nonlinear transport.
Real Hardware: The workflow was executed on IBM quantum processors (ibm_pittsburgh, ibm_boston, ibm_miami) for a single optimization iteration of a multigridding stage ( $2^3$ $2^{3}$ spatial, $2^2$ $2^{2}$ temporal points).
- The Nighthawk processor (square lattice) yielded shallower circuit depths than the Heron r3 (heavy-hex lattice) for the embedding circuits.
- Using the Estimator primitive with error mitigation (resilience level 2) on ibm_boston reduced the 2-norm error of the cost function variables to 0.27, compared to errors ranging from 1.33 to 2.92 for unmitigated Sampler runs.
- The study confirmed that despite current noise levels, accurate solutions are attainable for small-scale instances.
Scalability: Resource estimation suggests that with future improvements in coherence times and gate fidelities, the proposed method could achieve quantum advantage for problems with exponentially large discretization points (e.g., $2^{40}$ points) using roughly $O(10^2)$ qubits and execution times in the range of $O(10^2)$ hours on dedicated systems.

Significance and Claims
The paper claims to present a feasible workflow for solving nonlinear PDEs on quantum computers that performs well within current computational limits. The authors emphasize that their methodology demonstrates a path toward scaling up to an exponential number of spatial and temporal discretization points, provided that hardware decoherence times improve.

The authors maintain a modest tone regarding future implications, explicitly noting several caveats:

The current truncation order ( $\alpha=2$ ) is the minimum required; higher orders needed for complex flows (turbulence) may lead to divergence in error rates or exponential growth in system size.
The poor conditioning of the Carleman linearized matrix for large systems will likely require quantum preconditioning, which is an area of ongoing work.
The multigridding method's efficacy on exponentially large systems has not yet been empirically demonstrated due to current hardware noise limitations.
State preparation for initial conditions and efficient readout of the final solution remain significant challenges.

Ultimately, the work serves as a proof-of-concept that combines efficient data loading, variational optimization strategies, and error mitigation to solve a nonlinear fluid dynamics problem, suggesting that a quantum advantage is theoretically possible once hardware constraints are alleviated.

Technical Summary: A Scalable Approach to Solve the Carleman Linearized Burgers' Equation on a Quantum Computer

More like this