Ensemble QSP: Composable Quantum Signal Processing

• Ensemble QSP is a family of architectures that extend standard quantum signal processing by composing multiple QSP instances across modular, parallel, and recursive frameworks.
• It employs gadget-based formalisms and width-for-depth redistribution to relax the single-chain constraint, thereby optimizing circuit depth and enhancing output flexibility.
• Ensemble QSP also integrates ensemble averaging for error mitigation, preserving polynomial-transform semantics while managing noise without additional circuit depth.

The recent quantum-algorithm literature uses ensemble-style constructions to extend quantum signal processing (QSP) beyond a single sequential $SU(2)$ sequence. In that usage, “Ensemble QSP” does not denote one unique protocol; it refers to a family of architectures in which multiple QSP instances are composed, parallelized, distributed across a higher-dimensional control space, assigned to different dynamical sectors, or averaged across noisy realizations. Across these formulations, the common objective is to preserve the polynomial-transform semantics of QSP while relaxing the single-chain constraint that ordinarily ties degree, depth, and error sensitivity together (Rossi et al., 2023, Martyn et al., 2024, Laneve, 2023, Gomes et al., 2024, Liu et al., 27 Jan 2026).

1. Sequential QSP as the baseline

Standard QSP is organized around alternating a signal-dependent unitary and phase rotations. One formulation reviewed in the many-body literature is

$$U_{\vec\phi}(a)=S(\phi_0)\prod_{r=1}^{d}\bigl[W(a)S(\phi_r)\bigr],$$

with

$W(a)=e^{-iX\theta/2}, \qquad S(\phi)=e^{iZ\phi},$

and $a\in[-1,1]$. The resulting unitary has the form

$$U_{PQ}(a)= \begin{pmatrix} P(a) & iQ(a)\sqrt{1-a^2}\ iQ^*(a)\sqrt{1-a^2} & P^*(a) \end{pmatrix},$$

where $P$ and $Q$ satisfy the usual degree, parity, and unitarity constraints (Egawa et al., 17 Mar 2026).

This sequential structure is algorithmically powerful but rigid. For degree-$d$ polynomial evaluation, standard QSP uses a single circuit whose depth scales linearly with $d$. In property-estimation settings, the sequential character is explicit: implementing a degree-$d$ polynomial necessitates $$U_{\vec\phi}(a)=S(\phi_0)\prod_{r=1}^{d}\bigl[W(a)S(\phi_r)\bigr],$$0 queries to the encoding, equating to a query depth $$U_{\vec\phi}(a)=S(\phi_0)\prod_{r=1}^{d}\bigl[W(a)S(\phi_r)\bigr],$$1 (Martyn et al., 2024). The main ensemble-style extensions arise precisely from attempts to alter that depth profile, broaden the output space, or make QSP subroutines reusable.

A recurrent source of confusion is terminological. In optical microcavity physics, $$U_{\vec\phi}(a)=S(\phi_0)\prod_{r=1}^{d}\bigl[W(a)S(\phi_r)\bigr],$$2 denotes the “splitting quality” of scatterer-induced mode splitting, and the same paper defines an ensemble quantity

$$U_{\vec\phi}(a)=S(\phi_0)\prod_{r=1}^{d}\bigl[W(a)S(\phi_r)\bigr],$$3

That usage concerns optical mode splitting and Purcell-factor estimation rather than quantum signal processing (Ozdemir et al., 2011). In current quantum-algorithm usage, Ensemble QSP refers instead to ensemble-style constructions built on QSP/QSVT.

2. Modular gadget formalisms

A central modular formulation appears in “Modular quantum signal processing in many variables,” which treats QSP/QSVT routines as composable quantum subroutines rather than isolated polynomial-transformation procedures (Rossi et al., 2023). The basic unit is a gadget: an $$U_{\vec\phi}(a)=S(\phi_0)\prod_{r=1}^{d}\bigl[W(a)S(\phi_r)\bigr],$$4 gadget takes $$U_{\vec\phi}(a)=S(\phi_0)\prod_{r=1}^{d}\bigl[W(a)S(\phi_r)\bigr],$$5 single-qubit input oracles and outputs $$U_{\vec\phi}(a)=S(\phi_0)\prod_{r=1}^{d}\bigl[W(a)S(\phi_r)\bigr],$$6 single-qubit unitaries,

$$U_{\vec\phi}(a)=S(\phi_0)\prod_{r=1}^{d}\bigl[W(a)S(\phi_r)\bigr],$$7

Semantically, each output is identified through its top-left entry,

$$U_{\vec\phi}(a)=S(\phi_0)\prod_{r=1}^{d}\bigl[W(a)S(\phi_r)\bigr],$$8

so the object is a multi-input/multi-output transformation on functions, not merely a circuit fragment (Rossi et al., 2023).

The main obstruction to naïve composition is that QSP outputs are often only twisted embeddable rather than embeddable. The paper distinguishes

• embeddable unitaries $$U_{\vec\phi}(a)=S(\phi_0)\prod_{r=1}^{d}\bigl[W(a)S(\phi_r)\bigr],$$9,
• twisted embeddable unitaries $W(a)=e^{-iX\theta/2}, \qquad S(\phi)=e^{iZ\phi},$0,
• and half-twisted embeddable variants with additional domain restrictions.

Because the unknown $W(a)=e^{-iX\theta/2}, \qquad S(\phi)=e^{iZ\phi},$1-conjugation spoils clean functional composition, the paper introduces a correction protocol that converts twisted-embeddable outputs into embeddable ones up to controlled approximation error: $W(a)=e^{-iX\theta/2}, \qquad S(\phi)=e^{iZ\phi},$2 with controlled/ancilla-assisted query complexity

$W(a)=e^{-iX\theta/2}, \qquad S(\phi)=e^{iZ\phi},$3

This correction is the enabling step that makes outputs “snappable” (Rossi et al., 2023).

Composition itself is formalized by an interlink $W(a)=e^{-iX\theta/2}, \qquad S(\phi)=e^{iZ\phi},$4, which specifies how output legs of one gadget are connected to input legs of another. If one gadget achieves $W(a)=e^{-iX\theta/2}, \qquad S(\phi)=e^{iZ\phi},$5 and an atomic gadget achieves $W(a)=e^{-iX\theta/2}, \qquad S(\phi)=e^{iZ\phi},$6, then interlinking yields a new gadget whose achieved function is the corresponding substitution/composition. The framework supports addition, multiplication, scaling, composition, and pinning/elision/permutation, and it is explicitly interpreted in programming-language terms as a monadic type. In the same work, a beta Python package, pyqsp, is provided for assembling gadgets and compiling them into circuits (Rossi et al., 2023).

Within this line of work, Ensemble QSP is therefore best understood as a compositional calculus: a network of corrected QSP/QSVT modules that preserves a function-level description throughout assembly.

3. Parallel, multi-output, and recursive constructions

A second major meaning of Ensemble QSP is width-for-depth redistribution. “Parallel Quantum Signal Processing Via Polynomial Factorization” factorizes a target polynomial $W(a)=e^{-iX\theta/2}, \qquad S(\phi)=e^{iZ\phi},$7 into $W(a)=e^{-iX\theta/2}, \qquad S(\phi)=e^{iZ\phi},$8 smaller polynomials,

$W(a)=e^{-iX\theta/2}, \qquad S(\phi)=e^{iZ\phi},$9

runs the corresponding QSP subroutines on $a\in[-1,1]$0 parallel systems, and recombines the outputs through a generalized SWAP-test-like interference measurement. For estimating $a\in[-1,1]$1, this reduces the query depth from $a\in[-1,1]$2 to $a\in[-1,1]$3, while increasing the number of measurements by a factor $a\in[-1,1]$4 (Martyn et al., 2024). The construction is explicitly motivated by distributed quantum computers and by time-space tradeoffs in property estimation.

A more structural enlargement of the output space appears in “Quantum signal processing over SU(N),” where the single control qubit is replaced by $a\in[-1,1]$5 control qubits, and the signal-processing operators live in $a\in[-1,1]$6. The output becomes

$a\in[-1,1]$7

so a single protocol carries a vector of $a\in[-1,1]$8 polynomials rather than one polynomial pair. In the linear-signal setting, the paper shows that this is possible exactly when $a\in[-1,1]$9 for every $$U_{PQ}(a)= \begin{pmatrix} P(a) & iQ(a)\sqrt{1-a^2}\ iQ^*(a)\sqrt{1-a^2} & P^*(a) \end{pmatrix},$$0 and $$U_{PQ}(a)= \begin{pmatrix} P(a) & iQ(a)\sqrt{1-a^2}\ iQ^*(a)\sqrt{1-a^2} & P^*(a) \end{pmatrix},$$1 on $$U_{PQ}(a)= \begin{pmatrix} P(a) & iQ(a)\sqrt{1-a^2}\ iQ^*(a)\sqrt{1-a^2} & P^*(a) \end{pmatrix},$$2 (Laneve, 2023).

The same paper introduces an exponential-step signal operator

$$U_{PQ}(a)= \begin{pmatrix} P(a) & iQ(a)\sqrt{1-a^2}\ iQ^*(a)\sqrt{1-a^2} & P^*(a) \end{pmatrix},$$3

which permits much larger degree jumps per step. For degree at most $$U_{PQ}(a)= \begin{pmatrix} P(a) & iQ(a)\sqrt{1-a^2}\ iQ^*(a)\sqrt{1-a^2} & P^*(a) \end{pmatrix},$$4, there exist $$U_{PQ}(a)= \begin{pmatrix} P(a) & iQ(a)\sqrt{1-a^2}\ iQ^*(a)\sqrt{1-a^2} & P^*(a) \end{pmatrix},$$5 such that

$$U_{PQ}(a)= \begin{pmatrix} P(a) & iQ(a)\sqrt{1-a^2}\ iQ^*(a)\sqrt{1-a^2} & P^*(a) \end{pmatrix},$$6

iff the coefficient polynomials have degree at most $$U_{PQ}(a)= \begin{pmatrix} P(a) & iQ(a)\sqrt{1-a^2}\ iQ^*(a)\sqrt{1-a^2} & P^*(a) \end{pmatrix},$$7, satisfy normalization on the unit circle, and have pairwise orthogonal coefficient vectors. This gives a one-step universality statement for a class of polynomial states and recasts phase estimation and discrete logarithm as special cases of multi-control QSP (Laneve, 2023).

Recursive composition supplies a third ensemble-style mechanism. “Multivariable QSP and Bosonic Quantum Simulation using Iterated Quantum Signal Processing” defines iterated QSP as recursively applying QSP to the outputs of other QSP/QET transformations (Gomes et al., 2024). Its core squaring routine starts from $$U_{PQ}(a)= \begin{pmatrix} P(a) & iQ(a)\sqrt{1-a^2}\ iQ^*(a)\sqrt{1-a^2} & P^*(a) \end{pmatrix},$$8 and constructs a $$U_{PQ}(a)= \begin{pmatrix} P(a) & iQ(a)\sqrt{1-a^2}\ iQ^*(a)\sqrt{1-a^2} & P^*(a) \end{pmatrix},$$9-block encoding of

$P$0

using

$P$1

queries to $P$2. Through identities such as

$P$3

the paper builds multiplication, higher-order products, and, in its stated scope, any bounded degree multi-variate polynomial function of a set of phase angles (Gomes et al., 2024).

Taken together, these works define Ensemble QSP as either concurrent execution of smaller QSP factors, coherent production of vector-valued polynomial outputs in higher-dimensional control space, or recursive assembly of QSP-produced functions into larger polynomial architectures.

4. Ensemble averaging for error mitigation

A more literal meaning of Ensemble QSP is introduced in “Ensemble-Based Quantum Signal Processing for Error Mitigation,” which addresses random coherent errors in QSP phase rotations (Liu et al., 27 Jan 2026). The noise model assumes additive phase noise on the $P$4-rotation angles,

$P$5

with independent $P$6 drawn from even distributions. For a noisy gate

$P$7

the expectation value satisfies

$P$8

The corresponding theorem for a noisy QSP circuit states that the target polynomial survives in expectation up to a multiplicative attenuation factor: $P$9 Equivalently, the mean noisy circuit realizes the ideal transformation scaled by $Q$0 (Liu et al., 27 Jan 2026).

The ensemble strategy then consists of repeated noisy realizations plus averaging. For block-encoding $Q$1, the paper constructs many noisy copies of $Q$2, symmetrizes them to $Q$3, and combines them with an LCU construction. With

$Q$4

the method yields a block-encoding of

$Q$5

with probability at least $Q$6. For observables, the same idea is realized by measurement-level averaging rather than coherent averaging, using repeated noisy QSP subcircuits and a generalized Hadamard-test-type estimator (Liu et al., 27 Jan 2026).

The defining claim of this framework is that mitigation is obtained without increasing circuit depth or ancillary qubit requirements. Each realization has the same QSP depth $Q$7 as the noiseless circuit; the price is repetition count rather than deeper coherent structure. The trade-off is therefore shifted from depth to sample complexity, with repetition overhead governed by the attenuation factor and hence by the product $Q$8 in the mild-noise regime (Liu et al., 27 Jan 2026).

5. Physical and dynamical realizations

The hardware perspective clarifies why ensemble formulations matter. “Exploring experimental limit of deep quantum signal processing using a trapped-ion simulator” reports the first experimental realization of deep QSP circuits in a trapped-ion simulator, using a single trapped $Q$9 ion and circuit depths from 15 to 360 layers (Bu et al., 27 Feb 2025). The implemented trigonometric QSP sequence is

$d$0

The experiment studies STEP, SELU, and ReLU simulations and identifies a non-monotonic precision–noise trade-off: shallow circuits are approximation-limited, intermediate circuits perform best, and very deep circuits degrade because hardware noise accumulates. For STEP, the experimental MSE decreases from $d$1 at $d$2 to $d$3 at $d$4, then rises to $d$5 at $d$6 (Bu et al., 27 Feb 2025).

This result is directly relevant to ensemble designs. It implies that modular or repeated QSP is not limited by formal expressivity alone; it is limited by the hardware depth budget of its constituent blocks. The same paper also proves an error relation for the extended multi-qubit setting,

$d$7

assuming the signal unitary is noise-free, so single-qubit QSP error becomes a practical predictor for more elaborate QSVT/QPP constructions (Bu et al., 27 Feb 2025).

A different physical realization appears in “Quantum signal processing in Hilbert space fragmented systems,” where QSP is embedded into a many-body model with Hilbert space fragmentation (Egawa et al., 17 Mar 2026). In the integrable sector of the pair-hopping model, the fragment maps exactly to the spin-$d$8 XX chain, and the staggered four-fold potential supplies the complementary $d$9 axis required for QSP. Choosing $d$0 produces a sectorwise signal

$d$1

and the effective unitary in each BdG mode becomes

$d$2

The paper further shows that domain walls made of identical fractons act as separators, allowing multiple independent integrable fragments inside one sample and enabling parallel emulation in multiple disconnected sectors under the same global drive (Egawa et al., 17 Mar 2026).

This sectorwise control suggests a physical meaning of Ensemble QSP that is distinct from modular circuits or measurement averaging: multiple QSP channels are realized simultaneously because Hilbert space fragmentation partitions the dynamics into independently addressable fragments.

6. Mathematical envelope, related generalizations, and limitations

Several adjacent developments broaden the algebraic setting in ways that are compatible with ensemble interpretations. “Analytical Angle-Finding and Series Expansions for Quantum Signal Processing via Orthogonal Polynomial Theory” recasts QSP variants as basis-generation mechanisms. In that framework, OP-QSP generates orthogonal polynomial sequences on $d$3, generalized QSP generates Laurent biorthogonal polynomials, and $d$4-QSP generates orthogonal polynomials on the unit circle (Bernard et al., 6 May 2026). The paper derives explicit angle formulas for Hermite, Jacobi, and Rogers–Szegő families, proves that $d$5 rotation angles are required to encode polynomial sequences up to degree $d$6, and shows that a smooth function $d$7 can be $d$8-approximated with $d$9 gates via its Hermite series expansion (Bernard et al., 6 May 2026).

This basis viewpoint is important for Ensemble QSP because it turns QSP from a one-polynomial synthesis problem into a structured source of polynomial families that can be wrapped by LCU or inserted into modular networks. In the same paper, the bivariate setting yields biorthogonality properties and necessary achievability conditions, which indicates that multivariable ensemble constructions are constrained by moment-function and contour-integral structure rather than by purely formal substitution rules (Bernard et al., 6 May 2026).

“Complexification of Quantum Signal Processing and its Ramifications” extends the signal algebra from $d$0 to $d$1, with complex signal $d$2 and sequence

$d$3

For real $d$4, this reduces to ordinary $d$5 QSP; for purely imaginary $d$6, it reproduces $d$7-type QSP; for general complex $d$8, it lies in $d$9 and acts as a Lorentz transformation on density matrices after renormalization (Bastidas et al., 2024). The paper does not itself define Ensemble QSP, but its sequence-based, transfer-matrix formulation and hybrid unitary/measurement picture suggest a natural route to ensemble generalization. This suggests an enlarged setting in which one could study ensembles of complex signals, phase sequences, or bosonic Gaussian realizations (Bastidas et al., 2024).

Across the literature, several limitations are consistent. Parallel factorization reduces depth but incurs measurement overhead $$U_{\vec\phi}(a)=S(\phi_0)\prod_{r=1}^{d}\bigl[W(a)S(\phi_r)\bigr],$$00 (Martyn et al., 2024). Multi-control $$U_{\vec\phi}(a)=S(\phi_0)\prod_{r=1}^{d}\bigl[W(a)S(\phi_r)\bigr],$$01 QSP expands the output space but shifts the burden to implementing generic $$U_{\vec\phi}(a)=S(\phi_0)\prod_{r=1}^{d}\bigl[W(a)S(\phi_r)\bigr],$$02 signal-processing operators efficiently (Laneve, 2023). Measurement-averaged error mitigation preserves per-run depth but can become ill-conditioned when the attenuation factor is too small (Liu et al., 27 Jan 2026). Deep hardware realizations exhibit a genuine approximation–noise optimum rather than monotone benefit from higher degree (Bu et al., 27 Feb 2025). Modular and recursive approaches supply clean semantics, but they require correction procedures, domain restrictions, or explicit control of accumulated approximation error (Rossi et al., 2023, Gomes et al., 2024).

In that sense, Ensemble QSP is best regarded not as a single replacement for ordinary QSP, but as a technical umbrella over several strategies for distributing polynomial signal processing across modules, outputs, realizations, or physical sectors while retaining QSP’s function-transform semantics.