Many computational fluid dynamics (CFD) algorithms solve partial differential equations by discretization, resulting in large and sparse systems of linear equations. While iterative methods are widely used to solve these systems classically, most existing quantum linear system solvers target the solution through matrix inversion rather than approximating it using an iterative procedure. In this work, we develop a quantum implementation of the Jacobi method based on quantum singular value transformation (QSVT). By reformulating the Jacobi iteration as a polynomial transformation of a block-encoded operator, the algorithm requires only a constant ancilla overhead with respect to the number of iterations while maintaining a circuit depth that scales linearly with the iteration number. We demonstrate the algorithm for one- and two-dimensional Poisson problems, including the pressure Poisson equation arising in Chorin's projection method for the lid-driven cavity flow. The proposed algorithm provides a promising building block for future quantum implementations of multigrid methods and preconditioning techniques, bringing quantum algorithms closer to established CFD solution strategies.
AI Summary
The paper asks how to implement classical Jacobi iteration coherently without an ancilla register that grows with the iteration count. It rewrites the $k$-step iterate for $M=D^{-1}R$ as even and odd matrix polynomials acting on $D^{-1}b$, plus $(-M)^k x_0$. Three QSVT subroutines implement these terms, and an LCU construction combines them into a postselected state proportional to the Jacobi iterate.
For a Hermitian iteration matrix and an $m$-ancilla block encoding, the construction uses $\log_2N+m+3$ qubits and $3k-3$ block-encoding queries. The comparison implementation based on separate products and LCU uses $\log_2N+km+\lceil\log_2(k+1)\rceil$ qubits and $k(k+1)/2$ queries. For convergent Hermitian Jacobi iteration, the LCU normalization grows linearly in $k$, giving a success probability proportional to $\|x_k\|^2/(k\|D^{-1}b\|+\|x_0\|)^2$; amplitude amplification is suggested.
State-vector circuit simulations reproduce classical Jacobi iterates within $10^{-13}$ for one-dimensional Poisson examples and $10^{-12}$ for two-dimensional grids up to $32\times32$, with up to 80 iterations. A lid-driven-cavity demonstration modifies the boundary treatment using the previous pressure field; its pressure difference from the original-system reference is about $10^{-6}$ after 600 pseudo-time steps.
Applicability is restricted to Hermitian iteration matrices. The same QSVT construction does not implement the non-normal operators arising in Gauss–Seidel iteration. Resources are counted in generic block-encoding queries rather than compiled gates; efficient block encodings, state preparation, readout, and integration into larger CFD workflows remain unresolved.
Little sign of AI-generated textIncrementalStrong assumptionsMissing comparisonOverclaims
Error found: The abstract omits the essential Hermiticity restriction on the Jacobi iteration matrix M = D^{-1}R that is imposed in the algorithm's derivation.
The cavity-flow demonstration solves a modified pressure equation using previous-step boundary contributions, so agreement with the original pressure system is approximate rather than an exact implementation.
The printed LCU coefficients use ||b|| instead of ||D^{-1}b|| for the forcing branches, generally giving the wrong relative weight between the forcing and initial-guess contributions.
The printed one-dimensional Poisson system incorrectly scales the Dirichlet boundary corrections by Δx², affecting the stated nonzero-boundary benchmark.
Written by gpt-6.1-sol from the paper's full text. Automated: it can be wrong.
Many computational fluid dynamics (CFD) algorithms solve partial differential equations by discretization, resulting in large and sparse systems of linear equations. While iterative methods are widely used to solve these systems classically, most existing quantum linear system solvers target the solution through matrix inversion rather than approximating it using an iterative procedure. In this work, we develop a quantum implementation of the Jacobi method based on quantum singular value transformation (QSVT). By reformulating the Jacobi iteration as a polynomial transformation of a block-encoded operator, the algorithm requires only a constant ancilla overhead with respect to the number of iterations while maintaining a circuit depth that scales linearly with the iteration number. We demonstrate the algorithm for one- and two-dimensional Poisson problems, including the pressure Poisson equation arising in Chorin's projection method for the lid-driven cavity flow. The proposed algorithm provides a promising building block for future quantum implementations of multigrid methods and preconditioning techniques, bringing quantum algorithms closer to established CFD solution strategies.
The paper asks how to implement classical Jacobi iteration coherently without an ancilla register that grows with the iteration count. It rewrites the k-step iterate for M=D−1R as even and odd matrix polynomials acting on D−1b, plus (−M)kx0. Three QSVT subroutines implement these terms, and an LCU construction combines them into a postselected state proportional to the Jacobi iterate.
For a Hermitian iteration matrix and an m-ancilla block encoding, the construction uses log2N+m+3 qubits and 3k−3 block-encoding queries. The comparison implementation based on separate products and LCU uses log2N+km+⌈log2(k+1)⌉ qubits and k(k+1)/2 queries. For convergent Hermitian Jacobi iteration, the LCU normalization grows linearly in k, giving a success probability proportional to ∥xk∥2/(k∥D−1b∥+∥x0∥)2; amplitude amplification is suggested.
State-vector circuit simulations reproduce classical Jacobi iterates within 10−13 for one-dimensional Poisson examples and 10−12 for two-dimensional grids up to 32×32, with up to 80 iterations. A lid-driven-cavity demonstration modifies the boundary treatment using the previous pressure field; its pressure difference from the original-system reference is about 10−6 after 600 pseudo-time steps.
Applicability is restricted to Hermitian iteration matrices. The same QSVT construction does not implement the non-normal operators arising in Gauss–Seidel iteration. Resources are counted in generic block-encoding queries rather than compiled gates; efficient block encodings, state preparation, readout, and integration into larger CFD workflows remain unresolved.
We present a comprehensive review of quantum approaches for solving partial differential equations (PDEs) arising in computational fluid dynamics (CFD). We examine fully quantum approaches, including quantum linear system algorithms (QLSAs), ranging from the Harrow--Hassidim--Lloyd (HHL) algorithm to quantum singular value transformation (QSVT), Hamiltonian simulation, and quantum lattice Boltzmann methods (QLBMs), while emphasizing hybrid quantum--classical approaches, including quantum physics-informed neural networks (QPINNs) and amplitude-encoded variational PDE solvers. We focus on hardware-agnostic algorithms compatible with present noisy processors and emerging fault-tolerant architectures. For each framework, we analyze the mathematical formulation, algorithmic structure, and principal limitations. We also examine tensor-network (TN) representations, since CFD fields, differential operators, and geometrical information can often be encoded efficiently in low-rank form. The TN formalism bridges CFD discretizations and quantum states, operators, and circuits, enabling compact representations to be translated into tensor-programmable variational quantum algorithms (TP-VQAs). We further review benchmark problems, including Poisson, reaction, diffusion, and nonlinear model equations, and assess how well quantum algorithms capture key features of fluid dynamics. Our analysis highlights that potential quantum advantage is highly problem dependent and governed by condition number, representational complexity, state preparation, and measurement constraints. We outline capabilities, limitations, and challenges toward scalable quantum algorithms for CFD.
We focus on the electromagnetic fluid dynamics governing plasmas and develop a quantum algorithm for nonlinear partial differential equations. Specifically, we apply Koopman-von Neumann (KvN) linearization to transform the electromagnetic fluid dynamics into a Schrödinger equation. The time evolution of this system is then computed using Hamiltonian simulation via Quantum Singular Value Transformation (QSVT). The proposed quantum algorithm has the potential to significantly reduce computational complexity compared to an ideal classical high-precision scheme, which scales asO(Nx4)whereNxis the number of grid points per direction. By leveraging quantum computation, this complexity is reduced toO(NxlogNx)offering a potential advantage in large-scale simulations. To assess the feasibility and performance of quantum computing in plasma simulations, we implement the proposed quantum algorithm and conduct numerical validations. Specifically, we present results for two test cases: one with a linear solution and the other with a nonlinear solution. As a result, the behavior of composite numerical errors arising from discretization, KvN, and QSVT is elucidated, demonstrating the effectiveness of the proposed quantum algorithm. The novelty of this study lies in the application of a promising quantum algorithm for nonlinear partial differential equations to plasma simulations, along with a concrete numerical evaluation of its computational performance. Furthermore, this work presents a novel direction by identifying a nonlinear, high- degree-of-freedom physical system that can be efficiently solved by a quantum algorithm under theoretical guarantees.
We develop a quantum algorithm for solving high-dimensional fractional Poisson equations. By applying the Caffarelli-Silvestre extension, the d-dimensional fractional equation is reformulated as a local partial differential equation in d+1 dimensions. We propose a quantum algorithm for the finite element discretization of this local problem, by capturing the steady-state of the corresponding differential equations using the Schrödingerization approach from \cite{JLY22SchrShort, JLY22SchrLong, analogPDE}. The Schrödingerization technique transforms general linear partial and ordinary differential equations into Schrödinger-type systems, making them suitable for quantum simulation. This is achieved through the warped phase transformation, which maps the equation into a higher-dimensional space. We provide detailed implementations of the method and conduct a comprehensive complexity analysis, which can show up to exponential advantage -- with respect to the inverse of the mesh size in high dimensions -- compared to its classical counterpart. Specifically, while the classical method requires O(d1/233d/2h−d−2) operations, the quantum counterpart requires O(d33d/2h−2.5) queries to the block-encoding input models, with the quantum complexity being independent of the dimension d in terms of the inverse mesh size h−1. Numerical experiments are conducted to verify the validity of our formulation.
We develop new algorithms for Quantum Singular Value Transformation (QSVT), a unifying framework that encapsulates most known quantum algorithms and serves as the foundation for new ones. Existing implementations of QSVT rely on block encoding, incurring an intrinsic O(logL) ancilla overhead and circuit depth O(Ldλ) for polynomial transformations of a Hamiltonian H=∑k=1LHk, where d is the polynomial degree and λ=∑k∥Hk∥. We introduce a simple yet powerful approach that utilizes only basic Hamiltonian simulation techniques, namely, Trotter methods, to: (i) eliminate the need for block encoding, (ii) reduce the ancilla overhead to only a single qubit, and (iii) still maintain near-optimal complexity. Our method achieves a circuit depth of O(L(dλcomm)1+o(1)), without requiring any complicated multi-qubit controlled gates. Moreover, λcomm depends on the nested commutators of the terms of H and can be substantially smaller than λ for many physically relevant Hamiltonians, a feature absent in standard QSVT. To achieve these results, we make use of Richardson extrapolation in a novel way, systematically eliminating errors in any interleaved sequence of arbitrary unitaries and Hamiltonian evolution operators, thereby establishing a general framework that encompasses QSVT but is more broadly applicable. As applications, we develop end-to-end quantum algorithms for solving linear systems and estimating ground state properties of Hamiltonians, both achieving near-optimal complexity without relying on oracular access. Overall, our results establish a new framework for quantum algorithms, significantly reducing hardware overhead while maintaining near-optimal performance, with implications for both near-term and fault-tolerant quantum computing.
Abstract Solving computational fluid dynamics (CFD) problems requires the inversion of a linear system of equations, which can be done using a quantum algorithm for matrix inversion (Gilyén et al 2019 Proc. 51st Annual ACM SIGACT Symp. on Theory of Computing 193–204). However, the number of shots required to measure the output of the system can be prohibitive and remove any advantage obtained by quantum computing. In this work we propose a scheme for measuring the output of a quantum singular value transform (QSVT) matrix inversion algorithm specifically for the CFD use case. We use a quantum signal processing based amplitude estimation algorithm (Rall and Fuller 2023 Quantum 7 937) and show how it can be combined with the QSVT matrix inversion algorithm. We perform a detailed resource estimation of the amount of computational resources required for a single iteration of amplitude estimation, and compare the costs of amplitude estimation with the cost of not doing amplitude estimation and measuring the whole wavefunction. We also propose a measurement scheme to reduce the number of amplitudes measured in the CFD example by focussing on large amplitudes only. We simulate the whole CFD loop, finding that thus measuring only a small number of the total amplitudes in the output vector still results in an acceptable level of overall error.
Abstract Quantum linear system solvers like the quantum singular value transformation (QSVT) require a block encoding of the system matrix A within a unitary operator UA . Unfortunately, block encoding often results in significant subnormalisation and increase in the matrix’s effective condition number κ, affecting the efficiency of solvers. Matrix preconditioning is a well-established classical technique to reduce κ by multiplying A by a preconditioner P. Here, we study quantum preconditioning for block encodings. We consider four preconditioners and two encoding approaches: (a) separately encoding A and its preconditioner P, followed by quantum multiplication, and (b) classically multiplying A and P before encoding the product in U PA . Their impact on subnormalisation factors and condition number κ are analysed using practical matrices from computational fluid dynamics (CFD). Our results show that (a) quantum multiplication introduces excessive subnormalisation factors, negating improvements in κ. We study preamplified quantum multiplication to reduce subnormalisation. Conversely, we see that (b) encoding of the classical product can significantly improve the effective condition number using the sparse approximate inverse preconditioner with infill. Further, we introduce a new matrix filtering technique that reduces the circuit depth without adversely affecting the matrix solution. We apply these methods to reduce the number of QSVT phase factors by a factor of 25 for an example CFD matrix of size 1024 × 1024.