Quantum signal processing

Quantum signal processing is the one-qubit core behind modern Hamiltonian simulation and QSVT. It converts an eigenvalue into a rotation angle, applies a designed sequence of phase rotations, and uses the resulting amplitude as a polynomial in that eigenvalue.

TakesNothingWhat joins here

No input port at this edge: the record publishes no gate sequence and no register, so there is nothing here to read one off — and unlike a declared hole, nothing has been recorded about what belongs here.

Nothing in the Atlas meets this end.

ReturnsNothingWhat joins here

No output port at this edge: the record publishes no gate sequence and no register, so there is nothing here to read one off — and unlike a declared hole, nothing has been recorded about what belongs here.

Nothing in the Atlas meets this end.

This record publishes no gate sequence and no register, so there is nothing here to read an interface off. Absent rather than empty. See all 152 →

Quantum signal processing turns a scalar signal x into a rotation W(x), then applies a phase sequence. With a valid sequence, one measured amplitude implements a bounded polynomial P(x), which can approximate functions such as exp(−ixt) when the degree and phases are chosen correctly. The phase list is not arbitrary: synthesis must enforce the target polynomial's parity and boundedness, and the cost of implementing each signal query belongs in the final resource estimate.

TakesNothingWhat joins here

No input port at this edge: the record publishes no gate sequence and no register, so there is nothing here to read one off — and unlike a declared hole, nothing has been recorded about what belongs here.

Nothing in the Atlas meets this end.

ReturnsNothingWhat joins here

No output port at this edge: the record publishes no gate sequence and no register, so there is nothing here to read one off — and unlike a declared hole, nothing has been recorded about what belongs here.

Nothing in the Atlas meets this end.

This record publishes no gate sequence and no register, so there is nothing here to read an interface off. Absent rather than empty. See all 152 →

Signal: x ∈ [−1, 1]
Degree: At most one signal use per phase layer
Core primitive: Alternating Ry and Rz rotations
Signal proxy: W(x) = Ry(2 arccos x)
Output: Bounded polynomial P(x)
Key task: Phase synthesis from target polynomial

RZ(2φᵢ) on signal
W(x) on signal
RZ(2φᵢ₊₁) on signal

Target polynomial branch90%

Complementary branch10%

Quantum vs classical

Classical baseline

Classical polynomial approximation evaluates a polynomial on a known scalar or matrix representation; the quantum circuit evaluates it through signal queries and samples an amplitude.

Quantum claim

QSP can achieve near-optimal query scaling for promised spectral problems, but phase synthesis, block-encoding cost, precision, and readout remain essential.

How to compare

Compare polynomial approximation error and signal-query count, then include the cost of implementing each signal query on the target hardware.

Nobody has reviewed this record for gaps yet.

FrameworkNative

qsp_phase_sequence.py

from math import acos
from qiskit import QuantumCircuit

def qsp_skeleton(phases, x):
    if not -1 <= x <= 1:
        raise ValueError('signal must lie in [-1, 1]')
    qc = QuantumCircuit(1)
    for phase in phases:
        qc.rz(2 * phase, 0)
        qc.ry(2 * acos(x), 0)  # signal W(x)
    return qc

# A concrete instance, so the published record is a circuit and not a
# skeleton: three phases at signal x = 0.5.
FINAL_CIRCUIT = qsp_skeleton([0.3, -0.7, 0.4], 0.5)

Where this sits

This record is named by the layer graph at:

QSP phase factors Slot
Takes Chebyshev coefficients of a real polynomial $P$ of degree $d$ with definite parity and $|P(x)| \le 1$ on $[-1,1]$ , plus a target accuracy $\varepsilon$ . Returns A phase sequence $\Phi \in R^{d+1}$ , often symmetric ( $\phi_j = \phi_{d-j}$ ), together with the classical running time and the arithmetic precision the method requires.
Qubitization walk simulation Method
Takes An access model for $H$ — a sum of efficiently exponentiable terms, sparse-access oracles, or a block-encoding — plus an evolution time $t$ and a target error $\varepsilon$ . Returns A circuit approximating $e^{-iHt}$ to within $\varepsilon$ , with a stated query or gate count, an ancilla count, and the norm parameter — sparsity times $\lVert H\rVert_{\max}$ , or the LCU 1-norm — that the cost is measured against.

Related entries

Quantum singular value transformation
Algorithms
Transverse-field Ising simulation
Algorithms
Quantum phase estimation
Algorithms

Quantum vs classical

Classical baseline

Quantum claim

How to compare

Where this sits

Related entries

References