Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

arXiv:2404.02713

Quantum conjugate gradient method using the positive-side quantum eigenvalue transformation

Toyoizumi, Kiichiro, Kaito Wada, Naoki Yamamoto, K. Hoshino

Published Apr 3, 2024• 0 citations
arXivHTMLPDF

Abstract

Quantum algorithms are still challenging to solve linear systems of equations on real devices. This challenge arises from the need for deep circuits and numerous ancilla qubits. We introduce the quantum conjugate gradient (QCG) method using the quantum eigenvalue transformation (QET). The circuit depth of this algorithm depends on the square root of the coefficient matrix's condition number $κ$, representing a square root improvement compared to the previous quantum algorithms, while the total query complexity worsens. The number of ancilla qubits is constant, similar to other QET-based algorithms. Additionally, to implement the QCG method efficiently, we devise a QET-based technique that uses only the positive side of the polynomial (denoted by $P(x)$ for $x\in[0,1]$). We conduct numerical experiments by applying our algorithm to the one-dimensional Poisson equation and successfully solve it. Based on the numerical results, our algorithm significantly improves circuit depth, outperforming another QET-based algorithm by three to four orders of magnitude.

DOI
10.48550/arxiv.2404.02713

Related papers

Quantum Arnoldi and conjugate gradient iteration algorithm

Changpeng Shao

Arnoldi method and conjugate gradient method are important classical iteration methods in solving linear systems and estimating eigenvalues. Their efficiency often affected by the high dimension of the space, where quantum computer can play a role in. In this work, we establish their corresponding quantum algorithms. To achieve high efficiency, a new method about linear combination of quantum states will be proposed. The final complexity of quantum Arnoldi iteration method is $O(m^{3+\log (m/ε)}(\log n)^2 /ε^4)$ and the final complexity of quantum conjugate gradient iteration method is $O(m^{1+\log m/ε} (\log n)^2 κ/ε)$, where $ε$ is precision parameter, $m$ is the iteration steps, $n$ is the dimension of space and $κ$ is the condition number of the coefficient matrix of the linear system the conjugate gradient method works on. Compared with the classical methods, whose complexity are $O(mn^2+m^2n)$ and $O(mn^2)$ respectively, these two quantum algorithms provide us more efficient methods to solve linear systems and to compute eigenvalues and eigenvectors of general matrices. Different from the work \cite{rebentros}, the complexity here is almost polynomial in the iteration steps. Also this work is more general than the iteration method considered in \cite{kerenidis}.

arXiv:1807.07820•Jul 20, 2018•1 citation

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

Louisa M. Piskol, Thorsten Grahs, Stefan Langer +1 more

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.

quant-pharXiv:2609.24266•Sep 22, 2026•0 citations

Quantum Kaczmarz Algorithm for Solving Linear Algebraic Equations

Nhat A. Nghiem, Tuan K. Do, Trung V. Phan

We introduce a quantum linear system solving algorithm based on the Kaczmarz method, a widely used workhorse for large linear systems and least-squares problems that updates the solution by enforcing one equation at a time. Its simplicity and low memory cost make it a practical choice across data regression, tomographic reconstruction, and optimization. In contrast to many existing quantum linear solvers, our method does not rely on oracle access to query entries, relaxing a key practicality bottleneck. In particular, when the rank of the system of interest is sufficiently small and the rows of the matrix of interest admit an appropriate structure, we achieve circuit complexity $\mathcal{O}\left(\frac{1}{\varepsilon}\log m\right)$, where $m$ is the number of variables and $\varepsilon$ is the target precision, without dependence on the sparsity $s$, and could possibly be without explicit dependence on condition number $κ$. This shows a significant improvement over previous quantum linear solvers where the dependence on $κ,s$ is at least linear. At the same time, when the rows have an arbitrary structure and have at most $s$ nonzero entries, we obtain the circuit depth $\mathcal{O}\left(\frac{1}{\varepsilon}\log s\right)$ using extra $\mathcal{O}(s)$ ancilla qubits, so the depth grows only logarithmically with sparsity $s$. When the sparsity $s$ grows as $\mathcal{O}(\log m)$, then our method can achieve an exponential improvement with respect to circuit depth compared to existing quantum algorithms, while using (asymptotically) the same amount of qubits.

quant-pharXiv:2601.01342•Jan 6, 2026•0 citations

Quantum-compatible Riemannian conjugate gradient for ground-state preparation

Andres Arcia-Lopez, Marek Gluza, Yudai Suzuki +1 more

Riemannian optimization provides a natural geometric framework for designing quantum algorithms for ground-state preparation, most notably through quantum imaginary-time evolution. However, existing geometry-aware approaches primarily employ steepest-descent updates, leaving more advanced methods from classical Riemannian optimization largely unexplored. In this work, we introduce quantum conjugate gradient descent (QCGD), a quantum-compatible implementation of Riemannian conjugate gradient that combines the steepest descent direction with information retained from previous search directions. In our numerical experiments, the proposed approach achieves faster convergence per iteration than the baseline double-bracket quantum imaginary-time evolution (DB-QITE) algorithm, and we quantify the associated circuit cost with gate counts produced by Qrisp. This improvement, however, comes at the cost of increased circuit depth for each update step, revealing a trade-off between convergence rate and implementation complexity. Nevertheless, since the circuit depth for those algorithms grows exponentially with the number of iterations, the proposed method may offer practical advantages, particularly in the early fault-tolerant regime.

quant-pharXiv:2610.21782•Oct 16, 2026•0 citations

Depth-Optimized Quantum Circuit of Gauss–Jordan Elimination

Kyungbae Jang, Yujin Oh, Hwajeong Seo

Quantum computers have the capacity to solve certain complex problems more efficiently than classical computers. To fully leverage these quantum advantages, adapting classical arithmetic for quantum systems in a circuit level is essential. In this paper, we introduce a depth-optimized quantum circuit of Gauss–Jordan elimination for matrices in binary. This quantum circuit is a crucial module for accelerating Information Set Decoding (ISD) using Grover’s algorithm. ISD is a cryptographic technique used in analyzing code-based cryptographic algorithms. When combined with Grover’s search, it achieves a square root reduction in complexity. The proposed method emphasizes the potential for parallelization in the quantum circuit implementation of Gauss–Jordan elimination. We allocate additional ancilla qubits to enable parallel operations within the target matrix and further reuse these ancilla qubits to minimize overhead from our additional allocation. The proposed quantum circuit for Gauss–Jordan elimination achieves the lowest Toffoli depth compared to the-state-of-art previous works.

Applied Sciences•Sep 24, 2024•5 citations

Variational quantum algorithms for Poisson equations based on the decomposition of sparse Hamiltonians

Huimin Li, Zhi‐Xi Wang, Shao-Ming Fei

Solving a Poisson equation is generally reduced to solving a linear system with a coefficient matrix $A$ of entries ${a}_{ij}, i,j=1,2,...,n$, from the discretized Poisson equation. Although the variational quantum algorithms are promising algorithms to solve the discretized Poisson equation, they generally require that $A$ be decomposed into a sum of $O[\text{poly}({\text{log}}_{2}n)]$ simple operators in order to evaluate efficiently the loss function. A tensor product decomposition of $A$ with $2{\text{log}}_{2}n+1$ terms has been explored in previous works. In this paper, based on the decomposition of sparse Hamiltonians we greatly reduce the number of terms. We first write the loss function in terms of the operator ${\ensuremath{\sigma}}_{x}\ensuremath{\bigotimes}A$ with ${\ensuremath{\sigma}}_{x}$ denoting the standard Pauli operator. Then for the one-dimensional Poisson equations with different boundary conditions and for the $d$-dimensional Poisson equations with Dirichlet boundary conditions, we decompose ${\ensuremath{\sigma}}_{x}\ensuremath{\bigotimes}A$ into a sum of at most 7 and $(4d+1)$ Hermitian, one-sparse, and self-inverse operators, respectively. We design explicitly the quantum circuits to evaluate efficiently the loss function. The decomposition method and the design of quantum circuits can also be easily extended to linear systems with Hermitian and sparse coefficient matrices satisfying ${a}_{i,i+c}={a}_{c}$ for $c=0,1,...,n\ensuremath{-}1$ and $i=0,\ensuremath{\cdots},n\ensuremath{-}1\ensuremath{-}c$.

arXiv:2309.12826•Physical Review A•Sep 20, 2023•17 citations
Quantum algorithms are still challenging to solve linear systems of equations on real devices. This challenge arises from the need for deep circuits and numerous ancilla qubits. We introduce the quantum conjugate gradient (QCG) method using the quantum eigenvalue transformation (QET). The circuit depth of this algorithm depends on the square root of the coefficient matrix's condition number κκκ, representing a square root improvement compared to the previous quantum algorithms, while the total query complexity worsens. The number of ancilla qubits is constant, similar to other QET-based algorithms. Additionally, to implement the QCG method efficiently, we devise a QET-based technique that uses only the positive side of the polynomial (denoted by P(x)P(x)P(x) for x∈[0,1]x\in[0,1]x∈[0,1]). We conduct numerical experiments by applying our algorithm to the one-dimensional Poisson equation and successfully solve it. Based on the numerical results, our algorithm significantly improves circuit depth, outperforming another QET-based algorithm by three to four orders of magnitude.
Arnoldi method and conjugate gradient method are important classical iteration methods in solving linear systems and estimating eigenvalues. Their efficiency often affected by the high dimension of the space, where quantum computer can play a role in. In this work, we establish their corresponding quantum algorithms. To achieve high efficiency, a new method about linear combination of quantum states will be proposed. The final complexity of quantum Arnoldi iteration method is O(m3+log⁡(m/ε)(log⁡n)2/ε4)O(m^{3+\log (m/ε)}(\log n)^2 /ε^4)O(m3+log(m/ε)(logn)2/ε4) and the final complexity of quantum conjugate gradient iteration method is O(m1+log⁡m/ε(log⁡n)2κ/ε)O(m^{1+\log m/ε} (\log n)^2 κ/ε)O(m1+logm/ε(logn)2κ/ε), where εεε is precision parameter, mmm is the iteration steps, nnn is the dimension of space and κκκ is the condition number of the coefficient matrix of the linear system the conjugate gradient method works on. Compared with the classical methods, whose complexity are O(mn2+m2n)O(mn^2+m^2n)O(mn2+m2n) and O(mn2)O(mn^2)O(mn2) respectively, these two quantum algorithms provide us more efficient methods to solve linear systems and to compute eigenvalues and eigenvectors of general matrices. Different from the work \cite{rebentros}, the complexity here is almost polynomial in the iteration steps. Also this work is more general than the iteration method considered in \cite{kerenidis}.
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.
We introduce a quantum linear system solving algorithm based on the Kaczmarz method, a widely used workhorse for large linear systems and least-squares problems that updates the solution by enforcing one equation at a time. Its simplicity and low memory cost make it a practical choice across data regression, tomographic reconstruction, and optimization. In contrast to many existing quantum linear solvers, our method does not rely on oracle access to query entries, relaxing a key practicality bottleneck. In particular, when the rank of the system of interest is sufficiently small and the rows of the matrix of interest admit an appropriate structure, we achieve circuit complexity O(1εlog⁡m)\mathcal{O}\left(\frac{1}{\varepsilon}\log m\right)O(ε1​logm), where mmm is the number of variables and ε\varepsilonε is the target precision, without dependence on the sparsity sss, and could possibly be without explicit dependence on condition number κκκ. This shows a significant improvement over previous quantum linear solvers where the dependence on κ,sκ,sκ,s is at least linear. At the same time, when the rows have an arbitrary structure and have at most sss nonzero entries, we obtain the circuit depth O(1εlog⁡s)\mathcal{O}\left(\frac{1}{\varepsilon}\log s\right)O(ε1​logs) using extra O(s)\mathcal{O}(s)O(s) ancilla qubits, so the depth grows only logarithmically with sparsity sss. When the sparsity sss grows as O(log⁡m)\mathcal{O}(\log m)O(logm), then our method can achieve an exponential improvement with respect to circuit depth compared to existing quantum algorithms, while using (asymptotically) the same amount of qubits.
Riemannian optimization provides a natural geometric framework for designing quantum algorithms for ground-state preparation, most notably through quantum imaginary-time evolution. However, existing geometry-aware approaches primarily employ steepest-descent updates, leaving more advanced methods from classical Riemannian optimization largely unexplored. In this work, we introduce quantum conjugate gradient descent (QCGD), a quantum-compatible implementation of Riemannian conjugate gradient that combines the steepest descent direction with information retained from previous search directions. In our numerical experiments, the proposed approach achieves faster convergence per iteration than the baseline double-bracket quantum imaginary-time evolution (DB-QITE) algorithm, and we quantify the associated circuit cost with gate counts produced by Qrisp. This improvement, however, comes at the cost of increased circuit depth for each update step, revealing a trade-off between convergence rate and implementation complexity. Nevertheless, since the circuit depth for those algorithms grows exponentially with the number of iterations, the proposed method may offer practical advantages, particularly in the early fault-tolerant regime.
Quantum computers have the capacity to solve certain complex problems more efficiently than classical computers. To fully leverage these quantum advantages, adapting classical arithmetic for quantum systems in a circuit level is essential. In this paper, we introduce a depth-optimized quantum circuit of Gauss–Jordan elimination for matrices in binary. This quantum circuit is a crucial module for accelerating Information Set Decoding (ISD) using Grover’s algorithm. ISD is a cryptographic technique used in analyzing code-based cryptographic algorithms. When combined with Grover’s search, it achieves a square root reduction in complexity. The proposed method emphasizes the potential for parallelization in the quantum circuit implementation of Gauss–Jordan elimination. We allocate additional ancilla qubits to enable parallel operations within the target matrix and further reuse these ancilla qubits to minimize overhead from our additional allocation. The proposed quantum circuit for Gauss–Jordan elimination achieves the lowest Toffoli depth compared to the-state-of-art previous works.
Solving a Poisson equation is generally reduced to solving a linear system with a coefficient matrix AAA of entries aij,i,j=1,2,...,n{a}_{ij}, i,j=1,2,...,naij​,i,j=1,2,...,n, from the discretized Poisson equation. Although the variational quantum algorithms are promising algorithms to solve the discretized Poisson equation, they generally require that AAA be decomposed into a sum of O[poly(log2n)]O[\text{poly}({\text{log}}_{2}n)]O[poly(log2​n)] simple operators in order to evaluate efficiently the loss function. A tensor product decomposition of AAA with 2log2n+12{\text{log}}_{2}n+12log2​n+1 terms has been explored in previous works. In this paper, based on the decomposition of sparse Hamiltonians we greatly reduce the number of terms. We first write the loss function in terms of the operator ${\ensuremath{\sigma}}_{x}\ensuremath{\bigotimes}A$ with ${\ensuremath{\sigma}}_{x}$ denoting the standard Pauli operator. Then for the one-dimensional Poisson equations with different boundary conditions and for the ddd-dimensional Poisson equations with Dirichlet boundary conditions, we decompose ${\ensuremath{\sigma}}_{x}\ensuremath{\bigotimes}A$ into a sum of at most 7 and (4d+1)(4d+1)(4d+1) Hermitian, one-sparse, and self-inverse operators, respectively. We design explicitly the quantum circuits to evaluate efficiently the loss function. The decomposition method and the design of quantum circuits can also be easily extended to linear systems with Hermitian and sparse coefficient matrices satisfying ai,i+c=ac{a}_{i,i+c}={a}_{c}ai,i+c​=ac​ for $c=0,1,...,n\ensuremath{-}1$ and $i=0,\ensuremath{\cdots},n\ensuremath{-}1\ensuremath{-}c$.