Quantum linear-system algorithms access the coefficient matrix through a block-encoding oracle $U_A$ and the right-hand side through a state-preparation oracle $U_b$. The optimal query complexities of these two oracles are known separately: $O(κ\log(1/\varepsilon))$ queries to $U_A$ and $O(κ/s)$ queries to $U_b$, where $s=α\|A^{-1}b\|$. Whether a single algorithm can achieve both bounds simultaneously has remained open.
We resolve this question affirmatively. Given a constant-factor estimate of $s$, we give a quantum linear-system algorithm that prepares the normalized solution to error $\varepsilon$ using simultaneously $ O\left(κ\log\frac1\varepsilon\right)$ queries to $U_A$ and $O\left(κ/{s}\right)$ queries to $U_b$. The algorithm separates state preparation from precision refinement, so only the matrix-query count depends on the target accuracy.
We also prove a matching same-instance worst-case lower bound: for every quantum linear-system algorithm and every solution-norm scale, there exists a single Hermitian instance on which that algorithm requires both $Ω(κ\log(1/\varepsilon))$ matrix queries and $Ω(κ/s)$ state-preparation queries. Thus the two oracle complexities can be optimized simultaneously, and the resulting bounds are jointly optimal.
AI Summary
Quantum linear-system algorithms access $A$ through a block-encoding oracle $U_A$ and $b$ through a preparation oracle $U_b$. This paper asks whether one algorithm can attain the separately known optimal query bounds for both oracles, rather than trading matrix queries against repeated preparation of the right-hand side.
Given an exact $(\alpha,a,0)$ block-encoding, $\kappa\ge\alpha\|A^{-1}\|$, and a constant-factor estimate of $s=\alpha\|A^{-1}b\|$, the algorithm prepares the normalized solution to error $\varepsilon$ with success probability at least $2/3$, using simultaneously $O(\kappa\log(1/\varepsilon))$ matrix queries and $O(\kappa/s)$ preparation queries. Additional gates scale as $O(\kappa(a+1)\log(1/\varepsilon)+\kappa(1+\log d)/s)$.
The construction uses a transducer to prepare a constant-accuracy state with separately controlled oracle costs. A real Krylov-space invariant ensures that its projection onto an auxiliary kernel has exactly the required direction. Polynomial kernel filtering and a correction transformation then refine precision using only matrix queries. A computation-history reduction from parity, combined with a pointwise hybrid argument for preparation queries, establishes both matching lower bounds on a single Hermitian instance at every promised solution-norm scale.
The upper bound assumes the supplied norm estimate and access to controlled oracle calls and adjoints. The explicit implementation has large constant overheads. For a fixed approximate block-encoding with error $\delta_A$, the same asymptotic costs yield solution error at most $\varepsilon+2\kappa\delta_A/\alpha$, provided $\kappa\delta_A/\alpha\le1/4$; this robustness statement concerns a fixed encoded matrix, not time-varying oracle noise.
Little sign of AI-generated text
Written by gpt-6.1-sol from the paper's full text. Automated: it can be wrong.
Quantum linear-system algorithms access the coefficient matrix through a block-encoding oracle UA and the right-hand side through a state-preparation oracle Ub. The optimal query complexities of these two oracles are known separately: O(κlog(1/ε)) queries to UA and O(κ/s) queries to Ub, where s=α∥A−1b∥. Whether a single algorithm can achieve both bounds simultaneously has remained open.
We resolve this question affirmatively. Given a constant-factor estimate of s, we give a quantum linear-system algorithm that prepares the normalized solution to error ε using simultaneously O(κlogε1) queries to UA and O(κ/s) queries to Ub. The algorithm separates state preparation from precision refinement, so only the matrix-query count depends on the target accuracy.
We also prove a matching same-instance worst-case lower bound: for every quantum linear-system algorithm and every solution-norm scale, there exists a single Hermitian instance on which that algorithm requires both Ω(κlog(1/ε)) matrix queries and Ω(κ/s) state-preparation queries. Thus the two oracle complexities can be optimized simultaneously, and the resulting bounds are jointly optimal.
Quantum linear-system algorithms access A through a block-encoding oracle UA and b through a preparation oracle Ub. This paper asks whether one algorithm can attain the separately known optimal query bounds for both oracles, rather than trading matrix queries against repeated preparation of the right-hand side.
Given an exact (α,a,0) block-encoding, κ≥α∥A−1∥, and a constant-factor estimate of s=α∥A−1b∥, the algorithm prepares the normalized solution to error ε with success probability at least 2/3, using simultaneously O(κlog(1/ε)) matrix queries and O(κ/s) preparation queries. Additional gates scale as O(κ(a+1)log(1/ε)+κ(1+logd)/s).
The construction uses a transducer to prepare a constant-accuracy state with separately controlled oracle costs. A real Krylov-space invariant ensures that its projection onto an auxiliary kernel has exactly the required direction. Polynomial kernel filtering and a correction transformation then refine precision using only matrix queries. A computation-history reduction from parity, combined with a pointwise hybrid argument for preparation queries, establishes both matching lower bounds on a single Hermitian instance at every promised solution-norm scale.
The upper bound assumes the supplied norm estimate and access to controlled oracle calls and adjoints. The explicit implementation has large constant overheads. For a fixed approximate block-encoding with error δA, the same asymptotic costs yield solution error at most ε+2κδA/α, provided κδA/α≤1/4; this robustness statement concerns a fixed encoded matrix, not time-varying oracle noise.
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.
Quantum algorithms for linear systems produce the solution state A − 1 | b ⟩ by querying two oracles: O A that block encodes the coefficient matrix and O b that prepares the initial state. We present a quantum linear system algorithm making Θ ( 1 / p ) queries to O b , which is optimal in the success probability, and O ( κ log ( 1 / p ) ( log log ( 1 / p ) + log ( 1 / ϵ ) ) ) queries to O A , nearly optimal in all parameters including the condition number and accuracy. Notably, our complexity scaling of initial state preparation holds even when p is not known a priori . This contrasts with recent results achieving O ( κ log ( 1 / ϵ ) ) complexity to both oracles, which, while optimal in O A , is highly suboptimal in O b as κ can be arbitrarily larger than 1 / p . In various applications such as solving differential equations, preparing ground states of operators with real spectra, and estimating and transforming eigenvalues of non-normal matrices, we can further improve the dependence on p using a block preconditioning scheme to nearly match or outperform best p
Quantum linear systems algorithms (QLSAs) aim to solve linear systems $A\bb{x}=\bb{b}$ exponentially faster than classical methods under certain conditions. In this work, we develop quantum algorithms for solving linear algebraic equations from an ODE-based perspective. Inspired by the linear combination of Hamiltonian simulation (LCHS) representation in the Fourier approach \cite{Childs2017QLSA}, we express the solution $\bb{x}$ as a linear combination of solutions to a system of linear convection equations, which become Schrödinger-type equations with unitary evolutions in the Fourier domain. We refer to this representation as LC-Schrödingerization. Based on this result, we construct an LCHS-based quantum algorithm with two LCHS instances: one for time-marching and one for numerical integration. The key construction uses the derivative of a Gaussian-smoothed hat function and recovers the solution over a fixed auxiliary interval. This permits a truncation time independent of the target accuracy and avoids the loss in success probability from selecting a single grid point. Periodization and explicit Fourier coefficients provide the corresponding projection error bounds. Under the stated oracle assumptions and given a constant-factor estimate of the solution norm, direct simulation of the select operators and block preconditioning achieve the optimal matrix-query complexity O(κAlogε1) without using variable-time amplitude amplification (VTAA). The same upper bound holds for queries to the right-hand-side preparation oracle.
The spectral condition number is a widely adopted measure of worst-case cost for quantum linear system solvers. Yet it can significantly overestimate the actual runtime for a typical problem instance. We present two quantum algorithms that produce the normalized solution ∣x⟩ of linear system Ax=∣b⟩ to accuracy ε with complexity independent of the condition number κ=∥A−1∥. We focus on the standard input model where A is accessed through a block encoding and ∣b⟩ is prepared by a unitary. But we also introduce an affine dilation model that encodes A and ∣b⟩ jointly, allowing further refinements of the query complexity. Our truncation-based solver makes an optimal number of queries to ∣b⟩ and O(κeffpolylog(εκeff)) queries to A. We prove a family of upper bounds on the effective condition number, including κeff≤ε1/t∥(A†A)−t/2∣x⟩∥1/t for positive even integer t and κeff≤ε1/t∥A−1†(A†A)−(t−1)/2∣x⟩∥1/t for positive odd t, overcoming the κ-barrier. Our filtering-based solver is extremely simple with a favorable runtime prefactor. In particular, the solver has query complexity 3ε∥A−1†∣x⟩∥ to leading order when the solution norm is known. We then present a similarly simple solution norm estimator with the same asymptotic cost up to logarithmic factors. Our quantum linear system solvers thus substantially improve a recent algorithm of Li, enabling faster quantum linear system solving beyond the condition number.
We determine the optimal query complexity of ground-state preparation to trace-distance error ε when an energy threshold in the spectral gap is known. Let UH be an α-block-encoding of a Hamiltonian with unique ground state ∣ψ0⟩, and suppose ∣⟨ψ0∣UI∣0⟩∣≥γ for a state-preparation oracle UI. The threshold lies at least Δ/2 above the ground-state energy and at least Δ/2 below every excited-state energy. We give two algorithms that prepare a state within trace distance ε of the ground state. One uses O((α/Δ)(γ−1+log(1/ε))) calls to UH in expectation; the other uses O((α/(γΔ))log(1/ε)) calls to UH in the worst case. We prove a lower bound matching the expected query count; the corresponding worst-case lower bound follows from Somma and de Wolf [SdW26]. The respective bounds on calls to UI are O(1/γ) in expectation and O(γ−1log(1/ε)) in the worst case. On (N+1)-dimensional systems, these UI bounds are also optimal when the expected or worst-case count of UH calls, respectively, is o((α/Δ)N). Both algorithms use a constant-accuracy spectral filter to construct a purifier, which we then sequentially compose during amplitude amplification to prepare a state with constant overlap with the ground state. The expected-query algorithm repeats the preparation followed by one high-accuracy spectral filter until success. The worst-case algorithm uses filters of increasing accuracy and limits the total number of queries.
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.