⚛️ quantum physics

A QSVT-Based Quantum Jacobi Algorithm for Linear Systems with Application to the Poisson Equation

This paper presents a quantum Jacobi algorithm based on quantum singular value transformation (QSVT) that efficiently solves large sparse linear systems arising from partial differential equations, such as the Poisson equation in computational fluid dynamics, by reformulating iterative Jacobi steps as polynomial transformations with constant ancilla overhead and linear circuit depth scaling.

Original authors: Louisa M. Piskol, Thorsten Grahs, Stefan Langer, Oleksandr Kyriienko

Published 2026-09-22

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Louisa M. Piskol, Thorsten Grahs, Stefan Langer, Oleksandr Kyriienko

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

Predicting how fluids move is a cornerstone of modern engineering, from designing efficient aircraft wings to modeling weather patterns. To do this, scientists break down the complex, swirling equations that govern fluid flow into a massive grid of points. At each point, the computer must solve a simple relationship between its neighbors. When these relationships are combined, they form a gigantic puzzle of linear equations. Solving this puzzle is the most expensive part of the simulation, often consuming the majority of a supercomputer's time. For decades, engineers have relied on iterative methods to solve these puzzles, a process akin to refining a rough sketch into a detailed drawing by repeatedly adjusting the lines until they settle into the correct shape. While classical computers handle this well, the sheer size of the grids required for realistic simulations pushes the limits of even the most powerful machines.

Quantum computing offers a different path, promising to handle these massive grids by encoding information in the strange, overlapping states of quantum particles. However, most existing quantum approaches try to solve these fluid puzzles by inverting the entire mathematical structure at once, a method that is often too rigid or resource-heavy for the specific, step-by-step nature of fluid simulations. A team of researchers has now developed a new quantum algorithm that respects the iterative spirit of classical engineering. Instead of forcing a quantum computer to invert the whole system, they have adapted the classic Jacobi method—a simple, repeated adjustment technique—to run on quantum hardware. Their work shows that by using a specific mathematical tool called quantum singular value transformation, they can perform these repeated adjustments efficiently, keeping the number of extra quantum bits needed constant regardless of how many steps the calculation takes.

The researchers, working with institutions including Volkswagen and the German Aerospace Center, focused on a specific type of problem common in fluid dynamics: the Poisson equation. This equation appears whenever scientists need to ensure that a fluid flow remains consistent, such as when calculating pressure changes in a simulation of air moving over a car or inside a box. In a standard computer simulation, solving this equation involves a loop where the computer guesses a solution, checks the error, and corrects the guess, repeating this cycle hundreds or thousands of times. The team translated this loop into a quantum circuit. They realized that each step of the correction could be viewed as a polynomial transformation, a mathematical operation that reshapes the values in the system. By using quantum singular value transformation, they could apply this reshaping directly to the quantum state representing the fluid, effectively performing many steps of the correction process in a single, coherent quantum operation.

A major hurdle in previous attempts to run iterative methods on quantum computers was the accumulation of resources. Every time a quantum computer multiplies two matrices to perform a step in the calculation, it typically requires extra memory bits, known as ancilla qubits, to hold the intermediate results. In older quantum versions of the Jacobi method, the number of these extra bits grew linearly with the number of steps, quickly exhausting the limited capacity of current quantum devices. The new algorithm solves this by reformulating the iteration so that the extra bits remain constant. The researchers demonstrated that their method requires only a fixed, small number of extra qubits, regardless of whether the simulation runs for ten steps or a hundred. This efficiency comes at the cost of a circuit depth that grows linearly with the number of iterations, but this trade-off is favorable because it avoids the exponential resource explosion that plagued earlier attempts.

To test their idea, the team simulated the algorithm on a classical computer to see how it would behave on a real quantum machine. They first applied it to a simple one-dimensional problem, a basic model of fluid pressure, and found that the quantum algorithm reproduced the exact same results as the classical method, with errors so small they were effectively zero. They then moved to a more complex, two-dimensional scenario: the flow of air inside a square box where the top lid moves, dragging the air with it. This is a standard test case in engineering known as the lid-driven cavity flow. In this simulation, the pressure equation must be solved repeatedly as the air moves. The researchers showed that their quantum approach could handle the pressure calculations for this moving fluid, matching the classical solution with high precision. They also addressed a technical difficulty where the mathematical structure of the fluid equations did not perfectly fit the requirements of their quantum tool. They found that by slightly modifying the boundary conditions of the problem, they could make the equations compatible without significantly affecting the final physical result, a compromise that held up well in their simulations.

The study confirms that this polynomial-based approach is a viable building block for future quantum fluid simulations. It aligns quantum computing more closely with the actual strategies used by engineers today, rather than forcing fluid problems into a mold designed for pure mathematics. While the current work is a simulation and relies on the assumption that the fluid equations can be structured in a specific way, the results suggest a clear path forward. The authors note that this method could eventually serve as a component in larger, more advanced quantum workflows, such as those used for multigrid methods, which are the gold standard for speeding up fluid simulations on classical computers. By proving that a simple, repeated adjustment process can be efficiently encoded in a quantum circuit, the researchers have provided a practical step toward bringing quantum computing into the everyday toolkit of computational fluid dynamics.

Technical Summary: A QSVT-Based Quantum Jacobi Algorithm for Linear Systems with Application to the Poisson Equation

Problem Statement
Computational Fluid Dynamics (CFD) relies heavily on solving large, sparse systems of linear equations arising from the discretization of partial differential equations (PDEs), such as the Navier-Stokes equations. While classical CFD typically employs iterative methods (e.g., Jacobi, Gauss-Seidel) combined with preconditioners and multigrid techniques to solve these systems, existing Quantum Linear System Solvers (QLSS) predominantly focus on direct matrix inversion (e.g., HHL, QSVT-based inversion) rather than iterative approximation.

Previous attempts to implement iterative methods on quantum computers, such as the quantum Jacobi algorithm proposed by Williams et al., utilized Linear Combinations of Unitaries (LCU) to multiply block-encoded matrices. However, this approach suffers from a significant resource bottleneck: the number of required ancilla qubits grows linearly with the number of iterations ( $k$ ), and the circuit depth scales quadratically ( $O(k^2)$ ) due to the accumulation of block-encoding registers. This limits the scalability of such algorithms for the many iterations often required in CFD applications.

Methodology
The authors propose a novel quantum implementation of the Jacobi method that leverages Quantum Singular Value Transformation (QSVT) to overcome the resource scaling limitations of previous approaches.

Polynomial Reformulation: The classical Jacobi iteration $x_k = D^{-1}(b - Rx_{k-1})$ is reformulated as a polynomial transformation of the iteration matrix $M = D^{-1}R$ . The solution after $k$ iterations is expressed as a sum of terms involving powers of $M$ .
QSVT Integration: Instead of multiplying block-encoded matrices sequentially, the authors utilize QSVT to implement the polynomial transformation of the singular values (or eigenvalues, in the Hermitian case) of a block-encoded operator. The iteration is split into three components based on the parity of the exponents: even powers, odd powers, and the final term acting on the initial guess.
Circuit Construction:
- Three QSVT subroutines are constructed to approximate the even polynomial, odd polynomial, and the $k$ -th power term.
- These subroutines are combined using a Linear Combination of Unitaries (LCU) with only two ancilla qubits to encode the coefficients, regardless of the number of iterations.
- The algorithm requires the iteration matrix $M$ to be Hermitian (or normal), which imposes a structural constraint on the linear system (specifically, $A_{ij}A_{jj} = A_{ji}A_{ii}$ for real systems).
Resource Efficiency: By replacing sequential matrix multiplications with QSVT, the algorithm achieves a circuit depth that scales linearly with the number of iterations ( $O(k)$ ) and requires a constant number of ancilla qubits ( $O(1)$ ) relative to $k$ , in contrast to the linear ancilla growth and quadratic depth of the standard block-encoding multiplication approach.

Key Results
The authors validated the algorithm through numerical simulations using the PennyLane package:

1D Poisson Equation: The algorithm successfully solved the one-dimensional Poisson equation with various source functions. The quantum implementation reproduced the classical Jacobi solution up to machine precision (deviations $< 10^{-13}$ ) across different iteration counts ( $k=50$ to $250$).
2D Lid-Driven Cavity Flow: The method was applied to the pressure Poisson equation arising in Chorin's projection method for incompressible flow.
- Symmetrization Approximation: Since the standard discretization of the pressure Poisson equation with boundary conditions does not strictly satisfy the Hermitian requirement, the authors introduced a symmetrized linear system ( $Lx = b_{mod}$ ) where $L$ is the symmetric Laplacian and boundary condition deviations are treated as a correction term.
- Convergence: Simulations showed that while the symmetrization introduces an initial error, the convergence behavior of Chorin's projection method aligns with the reference solution as the simulation progresses. The error in the pressure field was found to be of the order of $10^{-6}$ and localized near boundaries, indicating the approximation has a minor impact on the overall CFD solution.
- Precision: For grid sizes up to $32 \times 32$ and iterations up to $k=80$ , the quantum algorithm reproduced classical iterates with deviations below $10^{-12}$ .
Resource Comparison: Theoretical analysis and Figure 3 demonstrate that the QSVT-enhanced algorithm significantly reduces both the number of ancillary qubits and the number of block-encoding calls compared to the original quantum Jacobi implementation.

Significance and Claims
The paper claims to provide a "promising building block" for integrating quantum algorithms into established CFD workflows. Its primary contributions are:

Algorithmic Efficiency: It demonstrates that iterative methods, which are central to modern CFD, can be implemented on quantum computers with constant ancilla overhead and linear circuit depth, addressing the scalability issues of previous gate-based iterative approaches.
CFD Relevance: By focusing on the Jacobi method and its application to the Poisson equation (a core component of projection methods), the work bridges the gap between abstract quantum linear solvers and practical CFD solution strategies.
Feasibility for Early Fault-Tolerant Devices: The explicit circuit construction and resource analysis suggest the algorithm is well-suited for early fault-tolerant quantum computers, provided efficient block encodings for relevant CFD operators can be constructed.

The authors modestly note that the requirement for a Hermitian iteration matrix restricts the general applicability of the method. They acknowledge that extending this polynomial-based approach to more advanced iterative schemes like Gauss-Seidel or Successive Over-Relaxation (SOR) is challenging due to the non-normality of their iteration operators, though they point to emerging frameworks like QEVT and GQSP as potential future avenues for overcoming these limitations. The work concludes that future research should focus on integrating these quantum iterative methods into larger frameworks, such as multigrid methods and preconditioning techniques.

More like this