# Quantum singular value transformation

Quantum singular value transformation (QSVT) is a quantum algorithmic framework that applies a chosen polynomial function to the singular values of a matrix embedded inside a larger unitary, using a circuit that alternates the embedding unitary with single-qubit phase rotations. Introduced by András Gilyén, Yuan Su, Guang Hao Low, and Isaac Chuang in 2019, it generalizes optimal [Hamiltonian simulation](https://www.edgepedia.org/hamiltonian-simulation) and provides a unified derivation of many quantum algorithms.<sup>[1](https://dl.acm.org/doi/10.1145/3313276.3316366)</sup>

| Key fact | Value |
|---|---|
| Core primitive | Apply a degree-d polynomial to the singular values of a block-encoded matrix using d uses of the encoding unitary and its inverse<sup>[1](https://dl.acm.org/doi/10.1145/3313276.3316366)</sup> |
| Achievability condition | Polynomial must be even or odd and bounded by 1 in absolute value on [−1, 1]<sup>[2](https://ewintang.com/assets/tang-pcmi-lectures.pdf)</sup> |
| Gate overhead per degree-d transform | d/2 calls to \(U_A\), d/2 to \(U_A^{\dagger}\), 2d multi-controlled Toffoli gates, d single-qubit Z rotations, one extra ancilla<sup>[3](https://lucidalu.github.io/Quantum-algorithms-A-survey-of-applications-and-end-to-end-complexities/quantum-algorithmic-primitives/quantum-linear-algebra/quantum-singular-value-transformation/)</sup> |
| Linear-system query complexity | O(κ log(κ/ε)) for QSVT; O(κ log(1/ε)) for the adiabatic-flavored Costa et al. method<sup>[4](https://arxiv.org/html/2502.20908)</sup><sup> • </sup><sup>[5](https://arxiv.org/html/2504.02385v2)</sup> |
| Optimal inversion polynomial degree | d ≈ 1.00 κ log(κ/ε) + 1<sup>[6](https://ar5iv.labs.arxiv.org/html/2507.15537)</sup> |
| Ancilla overhead | ⌈log₂L⌉ + 1 ancilla qubits in standard QSVT; one qubit in a 2025 Trotter-based variant<sup>[1](https://dl.acm.org/doi/10.1145/3313276.3316366)</sup><sup> • </sup><sup>[5](https://arxiv.org/html/2504.02385v2)</sup> |
| Main input-model caveat | Efficient block-encoding circuits must be assumed; O(log N) encodings for general matrices remain elusive<sup>[4](https://arxiv.org/html/2502.20908)</sup> |

## What QSVT is

The input to QSVT is a block-encoding: a unitary U whose top-left block is the target matrix A (scaled so its singular values lie in [0, 1]). Formally, this is the special case of a projected unitary encoding where both projectors are |0⟩⟨0| ⊗ I, so A is literally the top-left block of U.<sup>[1](https://dl.acm.org/doi/10.1145/3313276.3316366)</sup> Given such an encoding, QSVT applies a polynomial p to the singular values of A: the output circuit is a block-encoding of \(p^{(\mathrm{SV})}(A)\), the matrix obtained by replacing each singular value σ of A with p(σ) while leaving singular vectors unchanged.<sup>[7](https://doi.org/10.48550/arxiv.2302.14324)</sup>

Not every polynomial qualifies. A polynomial \(p\) with real coefficients is achievable if it is even or odd and satisfies \(|p(x)| \leq 1\) for all \(x \in [-1, 1]\); this is Theorem 17 and Corollary 18 of the original Gilyén–Su–Low–Chuang paper, as stated in [Ewin Tang](https://www.edgepedia.org/ewin-tang)'s PCMI lecture notes.<sup>[2](https://ewintang.com/assets/tang-pcmi-lectures.pdf)</sup> Functions that are not bounded polynomials, such as \(e^{x}\), must first be approximated by a suitable bounded polynomial, incurring an approximation error.<sup>[3](https://lucidalu.github.io/Quantum-algorithms-A-survey-of-applications-and-end-to-end-complexities/quantum-algorithmic-primitives/quantum-linear-algebra/quantum-singular-value-transformation/)</sup>

## How the construction works

 The mechanism comes from quantum signal processing (QSP): QSVT can be viewed as both a unification and a generalization of qubitization and QSP.<sup>[3](https://lucidalu.github.io/Quantum-algorithms-A-survey-of-applications-and-end-to-end-complexities/quantum-algorithmic-primitives/quantum-linear-algebra/quantum-singular-value-transformation/)</sup> For any degree-\(d\) odd polynomial \(P\) bounded by 1 on \([-1, 1]\), the resulting unitary \(U_{\Phi}\) uses \(U\) and \(U^{\dagger}\) a total of \(d\) times.<sup>[1](https://dl.acm.org/doi/10.1145/3313276.3316366)</sup> Given a phase sequence \(\Phi = \{\phi_{j}\}\) for \(j = 0..n\), the circuit \(U_{\Phi}\) is a block-encoding of \(p^{(\mathrm{SV})}(A)\) for the corresponding degree-\(n\) polynomial \(p\).<sup>[7](https://doi.org/10.48550/arxiv.2302.14324)</sup>

 The gate costs are explicit. Given a degree-\(d\) even-parity polynomial \(f\) mapping \([-1, 1]\) to \([-1, 1]\) and a \((1, m, 0)\)-block-encoding \(U_A\) of \(A\), one implements a block-encoding of \(f(A)\) using \(d/2\) calls to \(U_A\), \(d/2\) calls to \(U_A^\dagger\), \(2d\) m-controlled Toffoli gates, and \(d\) single-qubit Z rotations; the output is a \((1, m+1, 0)\)-block-encoding, using one more ancilla qubit than the input.<sup>[3](https://lucidalu.github.io/Quantum-algorithms-A-survey-of-applications-and-end-to-end-complexities/quantum-algorithmic-primitives/quantum-linear-algebra/quantum-singular-value-transformation/)</sup> Implementing a degree \(d+1\) odd polynomial costs one additional call to \(U_A\), two more Toffoli gates, and one more Z rotation.<sup>[3](https://lucidalu.github.io/Quantum-algorithms-A-survey-of-applications-and-end-to-end-complexities/quantum-algorithmic-primitives/quantum-linear-algebra/quantum-singular-value-transformation/)</sup> The phase angles in \(\Phi\) are found by efficient classical algorithms, giving a one-to-one correspondence between the polynomial and its circuit.<sup>[3](https://lucidalu.github.io/Quantum-algorithms-A-survey-of-applications-and-end-to-end-complexities/quantum-algorithmic-primitives/quantum-linear-algebra/quantum-singular-value-transformation/)</sup>

On the approximation side, truncated Chebyshev series suffice to match or nearly match the polynomial approximations QSVT needs. A "bounded Chebyshev truncation" theorem for piecewise-smooth functions, derived from Trefethen's classical bound, avoids Taylor and [Fourier series](https://www.edgepedia.org/fourier-series) entirely; it loses a logarithmic factor in some regimes but assumes a weaker condition on the function being approximated.<sup>[7](https://doi.org/10.48550/arxiv.2302.14324)</sup>

## Block-encodings: building the input

A block-encoding is the wrapper that makes A accessible to QSVT. The original paper provides a toolbox for constructing block-encodings of unitary matrices, density operators, POVM operators, sparse-access matrices, and matrices stored in QROM, and for forming linear combinations and products of block-encodings.<sup>[1](https://dl.acm.org/doi/10.1145/3313276.3316366)</sup> These composition rules are what let large algorithms be assembled from small encoded pieces.

Imperfect encodings degrade the output gracefully but noticeably. If \(U_A\) is an imperfect \((1, m, \varepsilon)\)-block-encoding of \(A\), the error in \(f(A)\) is bounded by \(4d\sqrt{\varepsilon}\), so the error grows with polynomial degree; if \(\|A\| \leq 1/2\), the bound improves to \(O(d\varepsilon)\).<sup>[3](https://lucidalu.github.io/Quantum-algorithms-A-survey-of-applications-and-end-to-end-complexities/quantum-algorithmic-primitives/quantum-linear-algebra/quantum-singular-value-transformation/)</sup>

The input model is the framework's main practical assumption. QSVT solvers require efficient block-encoding circuits for loading matrices, and block-encoding oracles of O(log N) cost for general-purpose matrices remain elusive; [block encoding](https://www.edgepedia.org/block-encoding) also often introduces significant subnormalization and increases the effective condition number κ.<sup>[4](https://arxiv.org/html/2502.20908)</sup>

## Solving linear systems with QSVT

To solve Ax = b, QSVT applies a polynomial approximation of 1/x to the singular values of A. Because QSVT polynomials are bounded by 1 on [−1, 1] but 1/x is not, a scale factor s is introduced and s·(1/x) is approximated instead. The approximation is only needed on [1/κ, 1], the interval set by the smallest singular value, since approximating 1/x near x = 0 would require very deep circuits.<sup>[8](https://pennylane.ai/demos/tutorial_apply_qsvt)</sup> The pipeline is: prepare the normalized vector b as a quantum state, apply the QSVT circuit implementing s·A⁻¹, and return the final state.<sup>[8](https://pennylane.ai/demos/tutorial_apply_qsvt)</sup> The required polynomial is an odd approximation to 1/x on [1/κ, 1], and known constructions achieve degree complexity O(κ log(κ/ε)) for condition number κ and uniform error ε.<sup>[6](https://ar5iv.labs.arxiv.org/html/2507.15537)</sup>

The resulting query complexity is \(O(\kappa \log(\kappa/\varepsilon))\), an exponential improvement in the precision \(\varepsilon\) over HHL's \(O(\log(N) \cdot s^2 \kappa^2/\varepsilon)\).<sup>[4](https://arxiv.org/html/2502.20908)</sup> The evidence does not state the precise state-preparation condition on the components of \(b\) (such as a \(b_i \geq \kappa/\kappa'\) threshold) or how the solution is extracted by amplitude amplification, so those details are not covered here.

## By the numbers

For the inversion polynomial, the degree determines circuit depth directly. The optimal polynomial has degree \(d \approx 1.00\,\kappa \log(\kappa/\epsilon) + 1\), compared with \(d \approx 1.12\,\kappa \log(\kappa/\epsilon) + 110\) for convex-optimization (CVX) polynomials, \(d \approx 2.62\,\kappa \log(\kappa/\epsilon) + 1368\) for Taylor expansion, and \(d \approx 1.01\,\kappa \log(\kappa/\epsilon) + 182\) for Chebyshev iteration.<sup>[6](https://ar5iv.labs.arxiv.org/html/2507.15537)</sup> The optimal polynomial's error at degree \(2n-1\) is \(\epsilon_{2n-1}(a) = (1-a)^{n} / (a(1+a)^{n-1})\) with \(a = 1/\kappa\), and the required degree satisfies \(n \sim (1/2)\,\kappa \log(\kappa/\epsilon)\).<sup>[6](https://ar5iv.labs.arxiv.org/html/2507.15537)</sup> For large \(\kappa \log(\kappa/\epsilon)\), the optimal polynomial also has the smallest maximum value on \([-1, 1]\) of the methods considered, which reduces circuit depth because of QSVT's normalization condition.<sup>[6](https://ar5iv.labs.arxiv.org/html/2507.15537)</sup>

At the solver level, the query complexities line up as follows: HHL at O(log(N) s² κ²/ε), LCU and QSVT at O(κ log(κ/ε)), and the discrete adiabatic method at the provably optimal O(κ log(1/ε)).<sup>[4](https://arxiv.org/html/2502.20908)</sup> Each degree-d QSVT transform costs d/2 + d/2 uses of the encoding unitary plus 2d Toffoli-class gates and d Z rotations.<sup>[3](https://lucidalu.github.io/Quantum-algorithms-A-survey-of-applications-and-end-to-end-complexities/quantum-algorithmic-primitives/quantum-linear-algebra/quantum-singular-value-transformation/)</sup>

## Variable-time, adiabatic-flavored, and block-encoding-free variants

The κ gap between QSVT and adiabatic methods is closed by the adiabatic-flavored approach of Costa et al., which achieves the optimal query complexity O(κ log(1/ε)) in queries to the block-encoding of A, using T = O(κ) discretization steps plus eigenstate filtering.<sup>[5](https://arxiv.org/html/2504.02385v2)</sup> That method uses ⌈log₂L⌉ + 6 ancillas and Õ(Lλκ) depth for a Hamiltonian H = Σ H_k with λ = Σ‖H_k‖.<sup>[5](https://arxiv.org/html/2504.02385v2)</sup>

A 2025 line of work removes the block-encoding requirement itself. Standard QSVT needs ⌈log₂L⌉ + 1 ancilla qubits and circuit depth Õ(Ldλ) for polynomial transformations of such a Hamiltonian. A Trotter-based QSVT variant reduces the ancilla overhead to a single qubit and achieves depth Õ(L(dλ_comm)^(1+o(1))), where λ_comm depends on nested commutators, without any complicated multi-qubit controlled gates.<sup>[5](https://arxiv.org/html/2504.02385v2)</sup> For linear systems specifically, an algorithm using only four ancilla qubits achieves total time Õ(L(λκ)^(1+o(1))) with Õ(ε⁻²) classical repetitions.<sup>[5](https://arxiv.org/html/2504.02385v2)</sup>

## How it compares with HHL, qubitization, and dequantization

QSVT is best understood as a unification. It can be viewed as both a generalization of [qubitization and quantum signal processing](https://www.edgepedia.org/qubitization-and-quantum-signal-processing), and it quickly derives optimal Hamiltonian simulation, Moore–Penrose pseudoinverse implementation with exponential precision, fixed-point amplitude amplification, a fast quantum OR lemma, and machine-learning algorithms such as principal component regression.<sup>[1](https://dl.acm.org/doi/10.1145/3313276.3316366)</sup><sup> • </sup><sup>[3](https://lucidalu.github.io/Quantum-algorithms-A-survey-of-applications-and-end-to-end-complexities/quantum-algorithmic-primitives/quantum-linear-algebra/quantum-singular-value-transformation/)</sup> A broader "grand unification" view places even Grover search and Hamiltonian simulation, which do not originally derive from phase estimation, inside the same framework.<sup>[9](https://www.osti.gov/servlets/purl/1982849)</sup>

Against phase-estimation-based HHL, QSVT improves precision dependence from \(1/\varepsilon\) to \(\log(1/\varepsilon)\).<sup>[4](https://arxiv.org/html/2502.20908)</sup> Whether this yields a genuine end-to-end speedup depends on the input model. For 2D second-order elliptic problems where \(\kappa\) scales as \(O(N^{2/d})\), QSVT query complexity is \(O(N \cdot \log(N/\varepsilon))\) versus classical conjugate gradient at \(O(N^{3/2} \cdot s \cdot \log(1/\varepsilon))\); the quantum solver has worse scaling in \(\kappa\) than CG but can still deliver a speedup, provided sufficiently efficient block encodings are available.<sup>[4](https://arxiv.org/html/2502.20908)</sup> The sources do not directly address how the dequantization critique applies to QSVT specifically, so that comparison is not settled here.

## References

1. Gilyén, Su, Low, Chuang. *Quantum singular value transformation and beyond: exponential improvements for quantum matrix arithmetics.* STOC 2019. https://dl.acm.org/doi/10.1145/3313276.3316366
2. Tang, E. *Quantum and quantum-inspired linear algebra* (PCMI lecture notes). https://ewintang.com/assets/tang-pcmi-lectures.pdf
3. Dalzell, A. *Quantum Singular Value Transformation*, in *Quantum Algorithms: A Survey of Applications and End-to-End Complexities*. https://lucidalu.github.io/Quantum-algorithms-A-survey-of-applications-and-end-to-end-complexities/quantum-algorithmic-primitives/quantum-linear-algebra/quantum-singular-value-transformation/
4. *Preconditioned block encodings for quantum linear systems.* arXiv 2502.20908 (2025). https://arxiv.org/html/2502.20908
5. *Quantum singular value transformation without block encodings: Near-optimal complexity with minimal ancilla.* arXiv 2504.02385 (2025). https://arxiv.org/html/2504.02385v2
6. *Matrix inversion polynomials for the quantum singular value transformation.* arXiv 2507.15537 (2025). https://ar5iv.labs.arxiv.org/html/2507.15537
7. *A CS guide to the quantum singular value transformation.* arXiv 2302.14324. https://doi.org/10.48550/arxiv.2302.14324
8. *QSVT in Practice.* PennyLane Demos. https://pennylane.ai/demos/tutorial_apply_qsvt
9. *Grand Unification of Quantum Algorithms.* PRX Quantum / DOE OSTI. https://www.osti.gov/servlets/purl/1982849

---
*Topic: Encyclopedia › Physical world and mathematics › Physics › Quantum physics › Quantum information science › Quantum computing and algorithms › Quantum algorithms › Quantum linear algebra and machine-learning subroutines › Block-encoding and QSVT linear solvers*

*Initially written Sep 17, 2026 · Reviewed: Sep 30, 2026 · Edited: Sep 30, 2026; Oct 11, 2026; Oct 21, 2026 · Last review: Sep 30, 2026*

*Copyright 2026 EdgeChat AI, a subsidiary of Biostate AI.*

License: Edgepedia Community License 1.0, https://www.edgepedia.org/edgepedia/license