Quantum Linear Solvers

Updated 4 September 2025

Quantum Linear Solvers are advanced quantum algorithms that generate quantum states proportional to the solution of Ax=b using techniques like quantum phase estimation.
They employ methods such as block encoding and quantum singular value transformation to achieve optimal query complexities and improved error management.
Practical implementations depend on matrix structure, QRAM availability, preconditioning strategies, and error scaling considerations for real-world applications.

Quantum Linear Solvers (QLSs) are quantum algorithms that address the task of solving linear systems of equations, i.e., preparing quantum states proportional to the solution of $A x = b$ for a given matrix $A$ and vector $b$ . QLSs serve as a cornerstone in quantum algorithms for simulation, optimization, and quantum machine learning by providing a quantum analog to one of the most ubiquitous classical linear algebra subroutines. QLSs offer asymptotic improvements in certain input models and for matrices with suitable structure, though the practical realization of these speedups depends on the interplay of condition number, sparsity, data access paradigm, and output observability.

1. Foundational Algorithms and Complexity Regimes

The Harrow-Hassidim-Lloyd (HHL) algorithm established the QLS paradigm, achieving polylogarithmic scaling in system size $N$ and polynomial scaling in the condition number $\kappa$ and target error $\epsilon$ . With a normalized Hermitian or Hermitian-embedded $A$ , the HHL circuit combines quantum phase estimation (QPE) and controlled rotations to effect amplitude inversions proportional to $1/\lambda_j$ for eigenvalues $\lambda_j$ of $A$ . The output is a quantum state $|x\rangle$ proportional to the solution vector, i.e.,

$|x\rangle = \sum_j \frac{b_j}{\lambda_j} |u_j\rangle /\|A^{-1} b\|$

where $|u_j\rangle$ and $b_j$ are the eigenvectors and expansion coefficients of $b$ , respectively.

Subsequent algorithmic advances shifted the efficiency focus to nearly optimal complexity in both $\kappa$ and $\epsilon$ , with query complexities $O(\kappa \log(1/\epsilon))$ for block-encoded matrices using the quantum singular value transformation (QSVT) and specialized amplitude amplification schemes (Jennings et al., 2023, Dalzell, 17 Jun 2024). The trade-off between practical constant prefactors and theoretical optimality is a recurrent theme: algorithms based on variable-time amplitude amplification and adiabatic path-following achieve optimal scaling but at the cost of heavy circuit resource overheads, while recent “kernel reflection” and eigenstate-filtering QLSs reduce this overhead to a minimum (Dalzell, 17 Jun 2024).

Algorithm	Oracle Complexity	Key Features
HHL	$O(\kappa^2 / \epsilon)$	QPE + controlled rotations
QSVT	$O(\kappa \log(1/\epsilon))$	Block encoding, Chebyshev polynomials
Adiabatic/QAOA-inspired	$O(\kappa \,\mathrm{polylog}(\kappa/\epsilon))$	Tuned scheduling, variational ansatz

2. Block Encoding, QSVT, and Functional QLS Paradigms

The “block encoding” framework encapsulates the representation of arbitrary (generally non-unitary and possibly non-Hermitian) matrices within larger unitary operators so that QSVT or LCU (Linear Combination of Unitaries) methods can effect polynomial transformations over their spectra. The block-encoding approach enables algorithmic reductions for inversion, exponentiation, and other functional calculus on matrices via circuits whose cost is dominated by controlled applications of the underlying $A$ -oracle.

Functional QLSs, such as those based on Chebyshev series (Gribling et al., 2021, Lefterovici et al., 27 Mar 2025), Fourier approximations (Lefterovici et al., 27 Mar 2025), and direct QSVT drives, realize the matrix inversion function efficiently. They employ polynomial or trigonometric approximants to $f(x) = 1/x$ truncated over spectral intervals, minimizing the degree for a specified error $\epsilon$ . Direct QSVT-based solvers consistently outperform both HHL and LCU-based methods regarding oracle query count on benchmark data sets (Lefterovici et al., 27 Mar 2025). This quantum signal processing approach can be formalized as

$A^{-1} \approx \sum_{k=0}^d c_k T_k(A)$

where $T_k$ are Chebyshev polynomials, and $d = O(\kappa \log(1/\epsilon))$ .

Comparison of functional QLSs across practical instance distributions reveals that HHL rapidly becomes impractical (query count grows as $O(\kappa^2/\epsilon)$ ), whereas QSVT and optimized LCU techniques achieve actual query reductions of many orders of magnitude for the same target precision and moderate-to-large system condition numbers (Lefterovici et al., 27 Mar 2025).

3. Quantum Gradient and Iterative Methods

Quantum-inspired iterative methods generalize classical gradient and stationary iterative solvers into the quantum setting. The quantum gradient descent formalism, developed for affine gradients, leverages approximate quantum step operators constructed via generalized singular value estimation (SVE) (Kerenidis et al., 2017), with controllable transformations ensuring unitary evolution despite the affine, non-normalizing character of classical updates.

The implementation introduces a “history state” that coherently superposes all iterates and employs amplitude amplification to retrieve a solution vector with controlled error: $\theta_{t+1} = \theta_{t} + \alpha (b - A\theta_{t})$ is translated to repeated unitary operations acting on quantum registers, with the essential structure: $|t \rangle | r_t \rangle |0\rangle \mapsto |t+1\rangle (|\tilde{S}(r_t)\rangle |0\rangle + |G_{t+1}\rangle |1\rangle)$ The error accumulates as $O(\alpha \tau^2 \epsilon)$ in $\tau$ iterations for per-step error $\epsilon$ . Applications demonstrated include positive semidefinite systems and quantum stochastic gradient descent for least squares, where efficient QRAM-based data access dramatically reduces quantum memory requirements relative to classical batched SGD.

4. Preconditioning, Fast Inversion, and Conditioning Mitigation

Preconditioning in quantum linear solvers aims to overcome the unfavorable scaling with condition number $\kappa$ . Quantum preconditioning primitives such as fast inversion (Tong et al., 2020) directly construct a block-encoding of $A^{-1}$ for diagonal or normal $A$ via classical arithmetic circuits, transforming the system $(A+B)x=b$ into

$W x = A^{-1} b \quad \textrm{with} \quad W = I + A^{-1}B$

thus transferring the effective condition dependence from $A$ to $B$ , which is typically of much smaller norm. Fast inversion-based preconditioning is particularly relevant in quantum many-body physics, such as for Green’s function evaluation in the Hubbard and Schwinger models.

Other frameworks, such as quantum proximal point methods, further reduce effective $\kappa$ by inverting $(I + \eta A)$ , with the modified system's condition number $\hat{\kappa} = \kappa (1 + \eta)/(\kappa + \eta)$ , enabling tunable trade-offs between convergence and conditioning (Kim et al., 19 Jun 2024). Such meta-algorithms directly wrap existing QLSP solvers.

5. Data Access, QRAM, and Large-Scale Applicability

The i/o model and data access paradigm are determinative for the practical efficiency of QLSs. In architectures equipped with QRAM or structured oracular block encoding, quantum state preparation and matrix element query can be performed in polylogarithmic time in system size $N$ , provided the matrix is stored in appropriate data structures (Kerenidis et al., 2017). The cost metrics in this setting often depend not on matrix size but effective norms $\mu(A)$ —such as row $\ell_1$ -norm bounds or Frobenius norm—in turn decoupling runtime from explicit matrix density for well-structured inputs.

In QRAM-enabled stochastic gradient descent variants, only subsets of data are loaded quantumly per iteration, enabling iterative quantum solvers for data-intensive applications (e.g., weighted least-squares regression) without requiring global coherent access to the entire dataset.

6. Practical Limitations, Error Scaling, and Implementation Challenges

Several caveats constrain the applicability of QLSs in practice:

The necessity of efficient, large-scale, fault-tolerant QRAM is an outstanding hardware challenge; contemporary architectures are not yet capable of achieving this precondition.
The precision error of QLSs accumulates with the number of iterations and can exhibit quadratic dependence on the number of steps in quantum iterative schemes. Coherently managing the trade-off between per-step precision and total error is essential to avoid exponential blow-up (Kerenidis et al., 2017).
For stochastic or variable-matrix updates, runtime scaling can degrade from linear to quadratic in the number of iterations because different updates may not commute or share a common spectral basis.
The quantum advantage is strongly contingent on matrix structure: systems with dense, ill-conditioned, or unstructured matrices do not generically guarantee a speedup over optimized classical solvers.
In quantum interior point methods and optimization, quantum linear solvers must be robust to highly ill-conditioned systems near optimality, necessitating inexact Newton steps combined with iterative refinement strategies (Mohammadisiahroudi et al., 2022).

7. Application Domains and Empirical Performance

QLSs underpin a variety of quantum protocols, including:

Quantum machine learning (notably for regression, support vector machines, and kernel methods)
Efficient simulation and solution of partial differential equations (e.g., finite element analysis (Raisuddin et al., 2023))
Quantum chemistry and materials science (e.g., evaluation of Green's functions and Gibbs state preparation (Tong et al., 2020))
Optimization via quantum interior point methods (Mohammadisiahroudi et al., 2022)
Large-scale linear systems arising in infrastructure modeling, including power systems (Zheng et al., 13 Feb 2024)
Emerging application: resource-efficient variational and shadow-based QLSs can solve Laplace or Ising grid problems on near-term devices, achieving polylogarithmic scaling in system size (Ghisoni et al., 13 Sep 2024)

Empirical resource benchmarking demonstrates that QSVT-based QLSs offer the lowest practical query complexities across real-world linear systems as encoded in MIPLIB simplex iterations and Poisson PDEs, dramatically outperforming HHL and LCU approaches in experiment (Lefterovici et al., 27 Mar 2025). For power grid applications, circuit resource reduction via optimized gate fusion and preconditioning enables quantum simulation backends to achieve multi-fold acceleration over non-optimized ones, while maintaining numerical fidelity (Zheng et al., 13 Feb 2024).

Quantum Linear Solvers thus represent a mature area combining quantum algorithmic innovation with deep linear algebraic structure. The field continues to address both asymptotic complexity and practical bottlenecks, with active developments in preconditioning techniques, QRAM architectures, error management for iterative and variational circuits, and integration with domain-specific applications.