Square-Root Sparsity and the Closure of the Quantum Linear Systems Query Gap: An Anatomical, Comparative, and Epistemic Review of Bravo-Prieto, Harrow, and Kothari
This review anatomises the argument of Bravo-Prieto, Harrow and Kothari (2026), hereafter BHK, that the query complexity of the quantum linear systems problem (QLSP) in the standard sparse-matrix oracle model is ( d log(1/ )). The paper closes a gap left by two incomparable upper bounds the discrete-adiabatic bound O( d log(1/ )) of Costa, An, Sanders, Su, Babbush and Berry (2022) and the spectral-norm simulation bound d ( d/ )o(1) of Low (2019) and by two partial lower bounds, ( log(1/ )) and ( d). The upper bound is not a new inversion primitive. It is a linear-algebraic enlargement: the factorisation A/ d = F T is split into two equations, each matrix entry is normalised separately, and the resulting contraction M, with M 5 d, is handed to an existing block-encoded solver. The lower bound multiplies unstructured search by a parity of length ( log(1/ )), with the quantum XOR lemma of Lee and Roland (2012) converting a vanishing advantage into a joint query lower bound. A corollary resolves the Berry and Childs (2012) question on black-box unitary implementation at O( N log(1/ )). The review reconstructs the proof anatomy, states pros and cons with explicit scope conditions, and compares BHK with fifteen neighbouring models spanning phase estimation, variable-time amplification, linear combinations of unitaries, adiabatic schedules, quantum singular value transformation, dense QRAM access, preconditioning, and the concurrent lower bound of Patel (2026). Also available on Academia.edu: https://www.academia.edu/attachments/134662881/download_file?s=portfolio
This review anatomises the argument of Bravo-Prieto, Harrow and Kothari (2026), hereafter BHK, that the query complexity of the quantum linear systems problem (QLSP) in the standard sparse-matrix oracle model is ( d log(1/ )). The paper closes a gap left by two incomparable upper bounds the discrete-adiabatic bound O( d log(1/ )) of Costa, An, Sanders, Su, Babbush and Berry (2022) and the spectral-norm simulation bound d ( d/ )o(1) of Low (2019) and by two partial lower bounds, ( log(1/ )) and ( d). The upper bound is not a new inversion primitive. It is a linear-algebraic enlargement: the factorisation A/ d = F T is split into two equations, each matrix entry is normalised separately, and the resulting contraction M, with M 5 d, is handed to an existing block-encoded solver. The lower bound multiplies unstructured search by a parity of length ( log(1/ )), with the quantum XOR lemma of Lee and Roland (2012) converting a vanishing advantage into a joint query lower bound. A corollary resolves the Berry and Childs (2012) question on black-box unitary implementation at O( N log(1/ )). The review reconstructs the proof anatomy, states pros and cons with explicit scope conditions, and compares BHK with fifteen neighbouring models spanning phase estimation, variable-time amplification, linear combinations of unitaries, adiabatic schedules, quantum singular value transformation, dense QRAM access, preconditioning, and the concurrent lower bound of Patel (2026). Also available on Academia.edu: https://www.academia.edu/attachments/134662881/download_file?s=portfolio
In the quantum linear systems problem (QLSP), we are given query access to a d-sparse N×N matrix A with condition number κ, and the ability to prepare a quantum state proportional to a vector b. The goal is to output an ε-approximation to the quantum state proportional to the solution x of Ax=b. Following a long line of work, the best previously known quantum algorithms for the QLSP had query complexities O(κdlog(1/ε)) and κd(κd/ε)o(1), while the best known lower bounds were Ω(κlog(1/ε)) and Ω(κd). We improve these bounds and show that the complexity of the QLSP is Θ(κdlog(1/ε)). We also resolve an open problem of Berry and Childs by showing that any N×N unitary can be implemented with bounded error using O(N) queries to its matrix entries.
This review anatomises Bravo-Prieto, Harrow and Kothari (2026) on the query complexity of the quantum linear systems problem in the standard sparse-matrix oracle model, which they show is Θ(κ √d log(1/ε)). The upper bound is a reduction: after an enlargement and per-entry normalisation, a contraction whose inverse norm is at most 5κ √d is handed to the existing block-encoded solver of Costa, An, Sanders, Su, Babbush and Berry (2022), giving O(κ √d log(1/ε)) sparse-oracle queries. The matching lower bound multiplies unstructured search by a parity of length Θ(κ log(1/ε)); the quantum XOR lemma of Lee and Roland (2012) converts a vanishing advantage into the joint query lower bound. A corollary implements an N × N unitary from its entries with O(√N log(1/ε)) queries, closing the black-box unitary question posed by Berry and Childs (2012). Primary source: Bravo-Prieto, C., Harrow, A.W. and Kothari, R. (2026), An Optimal Quantum Linear Systems Algorithm, arXiv:2609.35660. This deposit is a KSCCN review by Syed Muntasir Mamun, not the BHK paper. KSCCN review article, 3 October 2026. Dr. Syed Muntasir Mamun, ORCID 0000-0001-6845-2853. The views expressed are those of the author.
Quantum linear system (QLS) solvers are a fundamental class of quantum algorithms used in many potential quantum computing applications, including machine learning and solving differential equations. The performance of quantum algorithms is often measured by their query complexity, which quantifies the number of oracle calls required to access the input. The main parameters determining the complexity of QLS solvers are the condition number κ and sparsity s of the linear system, and the target error ε. To date, the best known query-complexity lower bound is Ω(κlog(1/ε)), which establishes the optimality of the most recent QLS solvers. The original proof of this lower bound is attributed to Harrow and Kothari, but their result is unpublished. Furthermore, when discussing a more general lower bound including the sparsity s of the linear system, it has become folklore that it should read as Ω(κslog(1/ε)). In this work, we establish the rigorous lower bound capturing the sparsity dependence of QLS. We prove the lower bound of Ω(κs) for any quantum algorithm that solves QLS with constant error. While the dependence on all parameters κ,s,ε remains an open problem, our result provides a crucial stepping stone toward the complete characterization of QLS complexity.
We give quantum algorithms for Hamiltonian simulation, linear differential equations, and linear systems with square-root dependence on sparsity. For an s-sparse Hermitian matrix with row and column Euclidean norms bounded by η, evolution for time t to error ε uses O(sτ+sτlog(1/ε)+log(1/ε)) queries, where τ=η∣t∣. The same bound holds for time-dependent Hamiltonians with coherent time-indexed sparse access and certified time discretisation. Our construction combines an exact entrywise representation with Cayley transducers. A joint lower bound nearly matches the time, sparsity, and precision dependence, ruling out a uniformly additive bound in sτ and log(1/ε). For dissipative linear differential equations we obtain O(gˉ[s(τ+τ)+1]log(Cgˉ/ε)) queries, where τ is the evolution time multiplied by a norm bound, gˉ bounds the ratio of combined input and source norms to the final-solution norm, and C is an absolute constant. We sharpen this bound by separating Hamiltonian and dissipative components, and treat general constant generators. Lower bounds capture joint parameter dependence for time-dependent equations and precision hardness for constant positive semidefinite dissipation. For linear systems, a Cayley walk and Chebyshev filter give O(κslog(1/ε)) queries when ∥A∥≤1 and ∥A−1∥≤κ, and we give an alternative proof of a matching joint lower bound. We also give gate-efficient implementations of time-independent Hamiltonian simulation and the dissipative ODE solver, including Lipschitz time dependence, retaining the query bounds with polylogarithmic overhead in inverse precision given efficient entry decoding, arithmetic, and required source preparations.
Quantum linear system solvers form one of the central algorithmic primitives in quantum computing, with applications ranging from differential equations and optimization to machine learning. Their cost is commonly measured through query complexity, which counts the number of oracle calls needed to access the input matrix. In the sparse-access model, this complexity is governed by three parameters: the condition number κ, the sparsity s of the input matrix, and the target precision ε. The dependence on κ and ε is already well understood through the lower bound Ω(κlog(1/ε)), which matches the best known scaling in these parameters. Once the sparsity s is included, however, the expected lower bound has long been conjectured to be Ω(κslog(1/ε)). Recent work by Mori et al. [Quantum Sci. Tech. 11 035063 (2026)] made an important step towards this goal by establishing the lower bound Ω(κs) for constant error ε. In this work, we complete the picture and prove the full joint lower bound Ω(κslog(1/ε)) in the sparse-access model, thereby establishing the anticipated dependence on all three parameters simultaneously.
Determining whether every trajectory of the linear system x˙=Ax converges to zero (or, equivalently, whether A is Hurwitz stable) is a fundamental problem in control theory. It arises, for example, in verifying the stability of feedback controllers and state observers, as well as of linearized dynamical models. We study the quantum query complexity of deciding whether a matrix A∈Cn×n is Hurwitz stable, given an exact normalized block-encoding of A. The query complexity is characterized in terms of the system dimension n and a supplied lower bound 0<ν≤ωA on the imaginary-axis distance ωA:=mint∈Rσmin(A−itI), where σmin(A) is the smallest singular value of A. We prove a query-complexity lower bound of Ω(n/ν), which holds even when A is restricted to be real and diagonal. For general matrices with nonzero ωA, we encode an approximation of the right-half-plane spectral projector sign+(A):=(I+sign(A))/2 as a block of a matrix inverse, where A is Hurwitz if and only if the projector is zero. To test this, we produce a quantum algorithm which determines if a (β,b,1/(4n))-block-encoded projector matrix (like sign+(A)) is zero or not; for constant success probability, it has complexity Θ(βn). When the zero test is applied to specific approximations of sign+(A), this yields an upper bound of O(nν−2log(n/ν)) queries in the general case, and O(nν−1logn) when A is Hermitian or normal. The latter upper bound matches the lower bound up to a logarithmic factor. Thus the dimension dependence of quantum Hurwitz testing is nearly optimal, while the remaining factor in the non-normal case isolates an open conditioning gap.