Quantum Linear System Solving Algorithms

• The Quantum Linear System Solving Algorithm is a quantum method that transforms the problem A x = b into a quantum state, enabling efficient estimation of observables.
• It leverages techniques such as phase estimation, block-encoding, and quantum signal processing to optimize complexity with respect to sparsity, condition number, and error tolerance.
• These algorithms power applications in quantum simulation, machine learning, and optimization, with advancements like structure-aware preconditioning enhancing practical performance.

Quantum Linear System Solving Algorithm

Quantum linear system solving algorithms (QLSSAs) constitute a class of quantum algorithms designed to produce a quantum state encoding the solution to a system of linear equations $A x = b$, with efficiency markedly superior to classical solvers in certain regimes. These algorithms underlie applications in quantum simulation, machine learning, optimization, and scientific computing, and are a foundational building block in the emerging landscape of quantum scientific and engineering algorithms. The QLSSA paradigm has evolved from the seminal HHL protocol to a taxonomy encompassing block-encoding, adiabatic, iterative, variational, and walk-based methodologies, each characterized by complexity bounds with respect to system size, sparsity, condition number, and error tolerance.

1. Formal Statement and Problem Instantiation

The quantum linear system problem (QLSP) is defined as follows. Given an $N\times N$ matrix $A$ (often Hermitian or positive-definite, $s$-sparse) and a vector $b \in \mathbb{C}^N$ (with efficiently preparable quantum state $|b\rangle$), prepare the normalized state

$|x\rangle \propto A^{-1} |b\rangle$

such that the fidelity error is $\leq \epsilon$. Rather than extracting the full solution vector $x\in\mathbb{C}^N$ classically, the quantum algorithm returns a state from which expectation values of observables $M$ can be estimated as $\langle x|M|x\rangle$ using quantum measurements.

The central complexity parameters are:

• Dimension ($N$): Encoded over $\log_2 N$ qubits.
• Sparsity ($s$): Maximum number of nonzero entries per row/column.
• Condition Number ($\kappa$): $\kappa = \|A\| \cdot \|A^{-1}\|$.
• Error tolerance ($\epsilon$): Target precision in trace-norm or fidelity.

2. The HHL Protocol and Phase Estimation-Based Methods

The HHL algorithm (Pan et al., 2013, Cai et al., 2013, Dervovic et al., 2018) is the earliest quantum algorithm for QLSP, leveraging quantum phase estimation (QPE), Hamiltonian simulation, and controlled rotations:

1. Hamiltonian Simulation: Implement $U = e^{-iA t}$; cost $O(s^2 t \, \mathrm{polylog}\,N)$ for $s$-sparse $A$.
2. Quantum Phase Estimation: Extract approximate eigenvalues $\tilde{\lambda}_j$ for decomposition $$A|u_j\rangle = \lambda_j |u_j\rangle, |b\rangle = \sum_j \beta_j |u_j\rangle$$.
3. Controlled Inverse Rotations: Apply rotation $R_y(2\arccos(C/\lambda_j))$ to ancilla, preparing amplitudes proportional to $1/\lambda_j$.
4. Uncomputation and Postselection: Uncompute eigenvalue register and post-select on the ancilla, yielding the desired state up to normalization.
5. Amplitude Amplification: Boosts postselection success probability, which otherwise scales as $O(1/\kappa^2)$.

HHL achieves gate complexity $O(s^2 \kappa^2 \log N / \epsilon)$, exponential in $N$ but quadratic in $\kappa$ and inverse-linear in $\epsilon$.

3. Block-Encoding, LCU, and Quantum Signal Processing Frameworks

Advancements have generalized QLSSA beyond QPE. The block-encoding paradigm (Dervovic et al., 2018, Clader et al., 2013, Wang et al., 2022, Vazquez et al., 2020) enables embedding arbitrary operators into unitaries with ancilla qubits, facilitating polynomial approximations to matrix inversion:

• Linear Combination of Unitaries (LCU): Approximates $A^{-1}$ as a truncated sum $\sum_k w_k U_k$ of efficiently simulable unitaries ($U_k = e^{-iA t_k}$).
• Quantum Signal Processing (QSP)/QSVT: Leverages Chebyshev or Fourier expansions and QSP circuits to implement polynomial transformations of the block-encoded operator.
• Complexity: Achieves runtime $$O(s \kappa \, \mathrm{polylog}(N, \kappa, 1/\epsilon))$$ for Hermitian, $s$-sparse $A$; removes $1/\epsilon$ dependence in favor of polylogarithmic scaling.
• Preconditioning: Embedding sparse approximate inverse preconditioners (Clader et al., 2013) or structure-aware right/left scaling (Li, 7 Oct 2025) further improves effective condition number.

4. Adiabatic, Discrete, and Randomized Evolution Approaches

Quantum adiabatic and walk-based solvers employ continuous or discretized Hamiltonian paths to interpolate between a trivial initial state and the desired solution (Costa et al., 2021, Jennings et al., 2023, An et al., 2019, Wu et al., 2024):

• Continuous Adiabatic Evolution: Adiabatic evolution using $H(s)$, with spectral gap scaling as $1/\kappa$.
• Discrete Adiabatic/Randomized Evolution: Implements the optimal schedule in stepwise fashion, rigorously bounding error with discrete adiabatic theorem. Complexity is $O(\kappa \log(1/\epsilon))$, matching lower bounds (Costa et al., 2021).
• Randomized Channel Techniques: Optimized random time quantum channels eliminate walk-operator overhead and minimize constant prefactors in $O(\kappa \log(1/\epsilon))$, with explicit gate-level resource analysis (Jennings et al., 2023).
• Momentum-Accelerated and Schrödingerized Dynamics: Embedding momentum-accelerated gradient descent into block Hamiltonian simulation (with Schrödingerization) yields linear-in-$\kappa$ scaling without deep ancilla layering (Hu et al., 20 Sep 2025).

5. Iterative, Gradient Descent, and Data-Driven Solvers

Quantum iterative algorithms (gradient descent, Kaczmarz) have emerged for special regimes:

• Gradient-Descent QLSA: Maintains operator-valued density state, updates iteratively by gradient steps; complexity is $$\sim s^2 (\log N)\log(1/\epsilon) + \log^{3.5}(s/\epsilon)$$, independent of $\kappa$ (Nghiem, 19 Feb 2025).
• Quantum Kaczmarz Algorithm: Expands the classical row-action method into the quantum block-encoding framework, requiring only state-prep (no QRAM/sparse oracle); gate complexity $$\mathcal{O}(2^{r_{A}} \|x^{(T)}\|_2 / \varepsilon \log m)$$, exponential in rank but linear in $1/\varepsilon$ (Nghiem et al., 4 Jan 2026).
• Shadow Quantum Linear Solver (SQLS): Merges variational quantum algorithms and classical shadow estimation to mitigate controlled-unitary overhead, achieving resource-efficient cost and matching scaling of block-encoding methods in the noiseless limit (Ghisoni et al., 2024).

6. Instance- and Structure-Dependent Algorithms

Algorithmic frameworks increasingly exploit input structure to circumvent or improve upon condition-number bottlenecks:

• Instance-Dependent Parameter $ET$: Introduces runtime dependence on $ET = \sum_{i=1}^M p_i^2 d_i$ (with $\vec{p} = (A A^\top)^+ \vec{b}$, $d_i = \|H_{i,*}\|_2^2$) rather than only $\kappa$, enabling efficient solution for certain polynomial systems and maximum independent set formulations (Li, 7 Oct 2025).
• Right-Rescaling Techniques: Diagonal right-multiplication reformulates linear systems, drastically reducing $\|z\|_2$ and $ET$ while traditional preconditioning leaves solution norm unchanged, enabling polynomial-time quantum solution even when $\kappa$ is exponential (Li, 7 Oct 2025).
• Quadratic $\sqrt{\kappa}$ Scaling in Positive-Definite Regimes: For diagonal-dominant or sum-of-local-Hamiltonian PD matrices, optimized block-encoding and pseudoinversion constructs deliver complexity $O(\sqrt{\kappa} \mathrm{polylog}(1/\epsilon))$ under certain overlaps and decompositions, paralleling classical conjugate-gradient improvements (Orsucci et al., 2021).

7. Applications, Experimental Realizations, and Resource Estimates

Quantum linear solvers have been empirically demonstrated on NMR systems and photonic platforms for small $N$ (Pan et al., 2013, Cai et al., 2013), and their applications span PDEs, data fitting, quantum machine learning, differential equation solvers, and cryptanalytic primitives:

• PDEs and Scientific Computing: Adiabatic/tensor format QLSAs solve discretized elliptic PDEs with polylogarithmic gate complexity in $N$ for fixed tensor rank (Wu et al., 2024).
• Electromagnetic and Scattering: Preconditioned QLSAs exponentially accelerate radar cross-section computations for finite element Maxwell equations (Clader et al., 2013).
• Polynomial System Solving: Structure-aware algorithms solve polynomial and combinatorial systems previously inaccessible to condition-number-based methods (Li, 7 Oct 2025).
• Cryptanalytic Subroutines: Binary field QLSAs realize rank and solution extraction in coherent superposition, with circuit cost matching theoretical lower bounds, and serve as building blocks for Simon-type attacks (Xia et al., 2024).
• Resource Analysis: Modern QLSSAs minimize ancillary qubits, exploit low-depth ansatzes, and eliminate QRAM dependence via amplitude encoding or classical control over entries (Nghiem et al., 4 Jan 2026, Ghisoni et al., 2024). Explicit gate-level and complexity bounds accompany most contemporary constructions.

8. Lower Bounds, Taxonomy, and Future Directions

Complexity lower bounds rigorously enforce linear-in-$\kappa$ scaling except in structured regimes (Costa et al., 2021, Orsucci et al., 2021), and algorithms are categorized by the following dimensions:

Paradigm	$\kappa$ scaling	$\epsilon$ scaling	Ancilla depth	Data Access
HHL/QPE	$O(\kappa^2)$	$O(1/\epsilon)$	High	Sparse oracles, qRAM
Block-encoding/QSP	$O(\kappa \mathrm{polylog}(1/\epsilon))$	Polylog	Moderate	Block-encoding, LCU
Adiabatic/Discrete	$O(\kappa \log(1/\epsilon))$	Logarithmic	Low	Sparse/block-encoding
Iterative/Kaczmarz	None or instance-dependent	$O(1/\epsilon)$	Low	Classical entry-lists/state
Structure-aware	$O(\sqrt{\kappa})$, $O(ET)$	Various	Moderate	Problem-structured

Active research directions include optimization of constant factors, exploration of data-driven and variational QLSSAs for NISQ devices, extensions to indefinite, dense, or non-Hermitian matrices, and rigorous analysis of instance-dependent complexity measures beyond $\kappa$.

---

This article encapsulates the technical landscape of quantum linear system solving algorithms as advanced in the past decade, from phase-estimation-based foundations to structure-aware, optimal-complexity meta-algorithms. Practitioners are advised to consult (Pan et al., 2013, Dervovic et al., 2018, Costa et al., 2021, Jennings et al., 2023, Nghiem et al., 4 Jan 2026, Li, 7 Oct 2025) for explicit implementations, proofs, benchmarks, and methodological innovations.