Implement Quantum Signal Processing (QSP) using orthogonal polynomial theory. Derive QSP angles analytically for Hermite, Jacobi, and Rogers-Szego polynomial families. Achieve O(log(1/ε)) gate complexity for ε-approximation of smooth functions via Hermite series expansion. Use when implementing QSP circuits, finding QSP angles, approximating functions via quantum signal processing, or connecting orthogonal polynomials to quantum algorithms. arXiv: 2605.05321
Implement Quantum Signal Processing (QSP) using orthogonal polynomial theory. Derive QSP angles analytically for Hermite, Jacobi, and Rogers-Szego polynomial families. Achieve O(log(1/ε)) gate complexity for ε-approximation of smooth functions via Hermite series expansion. Use when implementing QSP circuits, finding QSP angles, approximating functions via quantum signal processing, or connecting orthogonal polynomials to quantum algorithms. arXiv: 2605.05321
Quantum Signal Processing via Orthogonal Polynomials
Quantum Signal Processing (QSP) embeds polynomial transformations into quantum circuits.
This skill provides the analytical framework for finding QSP angles using orthogonal polynomial theory.
Core Result
QSP angles can be derived analytically (not numerically) for families of orthogonal polynomials:
Hermite polynomials → Gaussian-weighted function approximation
where W(x) is a signal oracle and θ_k are the QSP angles to be determined.
The achievable polynomials are characterized by their orthogonality or biorthogonality
with respect to a linear functional admitting an integral representation.
Analytical Angle-Finding
General Approach
For a target polynomial P(x) of degree d:
Express P(x) in an orthogonal polynomial basis {φ_k(x)}
Map basis coefficients to QSP angles via the orthogonality measure
Construct circuit with O(d) = O(log(1/ε)) gates
Hermite Polynomials
For functions f: ℝ → [-1, 1] with Gaussian weight:
import numpy as np
from scipy.special import hermite, roots_hermite
defhermite_qsp_angles(f, degree, weight_fn=None):
"""Compute QSP angles for Hermite polynomial approximation."""# Get Hermite-Gauss quadrature points
x, w = roots_hermite(degree + 1)
# Compute Hermite coefficients via quadrature
coeffs = []
for k inrange(degree + 1):
H_k = hermite(k)
c_k = np.sum(w * f(x) * H_k(x)) / np.sqrt(np.pi * 2**k * np.math.factorial(k))
coeffs.append(c_k)
# Map coefficients to QSP angles# Phase angles θ_k determined by the recurrence relation
angles = hermite_to_qsp_phases(coeffs)
return angles
Jacobi Polynomials
For functions on [-1, 1] with weight (1-x)^α(1+x)^β:
For phase-based transformations on the unit circle:
defrogers_szego_qsp_angles(f, degree, q_param=0.5):
"""Compute QSP angles for Rogers-Szegő polynomial approximation."""# Rogers-Szegő polynomials are orthogonal on the unit circle# with weight related to the q-parameter
angles = rs_to_qsp_phases(f, degree, q_param)
return angles
Gate Complexity
Approximation
Gate Complexity
Polynomial Family
ε-approximation of smooth f
O(log(1/ε))
Hermite
Degree-d polynomial
O(d)
Any orthogonal family
Bandlimited function
O(B · log(1/ε))
Sinc/Whittaker
The O(log(1/ε)) scaling for Hermite expansions is exponentially better than naive approaches.
Practical Implementation
Step 1: Choose Polynomial Family
Unbounded domain → Hermite polynomials
Bounded interval [-1,1] → Jacobi polynomials (includes Legendre, Chebyshev as special cases)
Phase/unit circle → Rogers-Szegő polynomials
Step 2: Compute Expansion Coefficients
Use numerical quadrature with the appropriate weight function:
