Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

arXiv:2502.15928

EHands: Quantum Protocol for Polynomial Computation on Real-Valued Encoded States

J. T. Balewski, Pestano, C., Mercy G. Amankwah, E. Wes Bethel, Talita Perciano, Roel Van Beeumen

Published Feb 21, 2025• 0 citations
arXivHTMLPDF

Abstract

We present EHands, a quantum-native protocol for implementing multivariable polynomial transformations on quantum processors. The protocol introduces four fundamental, reversible operators: multiplication, addition, negation, and parity flip, and employs the Expectation Value ENcoding (EVEN) scheme to represent real numbers as quantum states. Unlike discretization or binary encoding methods, EHands operates directly on vectorized real-valued inputs prepared in the initial state and applies a shallow quantum circuit that depends only on the polynomial coefficients. The result is obtained from the expectation value measured on a single qubit, enabling efficient parallel evaluation of a polynomial across multiple data points using a single circuit. We introduce both a reversible implementation for degree-$d$ polynomials, requiring $3d$ qubits, and a non-reversible variant that uses qubit resets to reduce the requirements to $d+1$ qubits. Both implementations exhibit linear depth scaling in $d$ and are explicitly decomposed into one- and two-qubit gates for direct execution on current quantum processing units. The protocol's effectiveness is demonstrated through experimental validation on IBM's Heron-class quantum processors, showing reliable polynomial approximations of functions like ReLU and arctan.

DOI
10.48550/arxiv.2502.15928

Related papers

Efficient explicit circuit for quantum state preparation of piecewise continuous functions

Nikita Guseynov, Nana Liu

Efficiently uploading data into quantum states is essential for many quantum algorithms to achieve advantage across various applications. In this paper, we address this challenge by developing a method to upload a polynomial function f ( x ) on the interval x ∈ [ − 1 , 1 ] into a pure quantum state consisting of qubits, where a discretized f ( x ) is the amplitude of this state. The preparation cost has O ( n log n ) scaling in the number of qubits n and linear scaling with the degree of the polynomial Q . This efficiency allows the preparation of states whose amplitudes correspond to high-degree polynomials (up to 10 4 ), enabling accurate approximation of functions that admit efficient polynomial series representations and whose amplitude profiles are not extremely localized. We provide a fully explicit circuit realization, based on four real polynomials that meet specific parity and boundedness conditions. We extend this construction to cover piecewise polynomial functions, a case not previously addressed explicitly in the literature, the algorithm scaling linearly with the number of piecewise parts. Our method achieves efficient quantum circuit implementation and we present detailed gate counting and resource analysis.

arXiv:2411.01131•Physical Review A•Dec 9, 2025•4 citations

Practical block encodings of matrix polynomials that can also be trivially controlled

Martina Nibbi, Filippo Della Chiara, Yizhi Shen +2 more

Quantum circuits naturally implement unitary operations on input quantum states. However, non-unitary operations can also be implemented through "block encodings", where additional ancilla qubits are introduced and later measured. While block encoding underlies a host of well-established theoretical applications, its implementation in practice has been prohibitively expensive for current quantum hardware. In this paper, we present practical and explicit block encoding circuits implementing matrix polynomial transformations of a target matrix. With standard approaches, block-encoding a degree-d matrix polynomial requires a circuit depth scaling as d times the depth for block-encoding the original matrix alone. By leveraging the recently introduced Fast One-Qubit Controlled Select Linear Combination of Unitaries (FOQCS-LCU) framework, we show that the additional circuit-depth overhead required for encoding matrix polynomials can be reduced to scale linearly in d with no dependence on system size or the cost of block encoding the original matrix. Moreover, we demonstrate that the FOQCS-LCU circuits and their associated matrix polynomial transformations can be controlled with negligible overhead, enabling efficient applications such as Hadamard tests. Finally, we provide explicit hardware-efficient circuits for representative non-unitary operators, namely quantum spin models, together with detailed non-asymptotic gate counts and circuit depths.

quant-pharXiv:2601.18767•Jan 27, 2026•0 citations

Logarithmic-depth quantum state preparation of polynomials

Baptiste Claudon, Alexis Lucas, Jean-Philip Piquemal +2 more

Quantum state preparation is a central primitive in many quantum algorithms, yet it is generally resource intensive, with efficient constructions known only for structured families of states. This work introduces a method for preparing quantum states whose amplitudes are given by a degree$-d$ polynomial, using circuits with logarithmic depth in the number $n$ of qubits and only $\mathcal O(n)$ ancilla qubits, improving previous approaches that required linear-depth circuits. The construction first relies on a block-encoding of an affine diagonal operator based on its Pauli-basis decomposition, which involves only $n$ terms. A modified linear-combination-of-unitaries (LCU) technique is introduced to implement this decomposition in logarithmic depth, together with a novel circuit for the EXACT-one oracle that flags basis states in which exactly one qubit is in the state $|1\rangle$. It then uses a generalized quantum eigenvalue transformation (GQET) to promote this affine operator to an arbitrary degree polynomial. Theoretical analysis and numerical simulations are reported along with a proof-of-principle implementation on a trapped-ion quantum processor using $14$ qubits and more than $500$ primitive quantum gates. Because polynomial approximations are ubiquitous in scientific computing, this construction provides a scalable and resource-efficient approach to quantum state preparation, further improving the potential of quantum algorithms in fields such as chemistry, physics, engineering, and finance.

quant-pharXiv:2603.16527•Mar 18, 2026•0 citations

Efficient quantum amplitude encoding of polynomial functions

Javier Gonzalez-Conde, Thomas W. Watts, Pablo Rodriguez-Grasa +1 more

Loading functions into quantum computers represents an essential step in several quantum algorithms, such as quantum partial differential equation solvers. Therefore, the inefficiency of this process leads to a major bottleneck for the application of these algorithms. Here, we present and compare two efficient methods for the amplitude encoding of real polynomial functions on n qubits. This case holds special relevance, as any continuous function on a closed interval can be uniformly approximated with arbitrary precision by a polynomial function. The first approach relies on the matrix product state representation (MPS). We study and benchmark the approximations of the target state when the bond dimension is assumed to be small. The second algorithm combines two subroutines. Initially we encode the linear function into the quantum registers either via its MPS or with a shallow sequence of multi-controlled gates that loads the linear function's Hadamard-Walsh series, and we explore how truncating the Hadamard-Walsh series of the linear function affects the final fidelity. Applying the inverse discrete Hadamard-Walsh transform converts the state encoding the series coefficients into an amplitude encoding of the linear function. Thus, we use this construction as a building block to achieve an exact block encoding of the amplitudes corresponding to the linear function on k0 qubits and apply the quantum singular value transformation that implements a polynomial transformation to the block encoding of the amplitudes. This unitary together with the Amplitude Amplification algorithm will enable us to prepare the quantum state that encodes the polynomial function on k0 qubits. Finally we pad n−k0 qubits to generate an approximated encoding of the polynomial on n qubits, analyzing the error depending on k0 . In this regard, our methodology proposes a method to improve the state-of-the-art complexity by introducing controllable errors.

arXiv:2307.10917•Quantum•Mar 21, 2024•40 citations

Multivariate quantum signal processing with optimal query complexity

Mingrui Jing, Xin Wang, Zhan Yu +1 more

Polynomial transformations of data encoded in quantum operations are a building block of quantum algorithms, and their query complexity measures how often those operations are used. For multiple variables, existing methods either realize restricted polynomial families or implement monomials separately at a query cost exponential in the number of variables. We present a quantum circuit that implements every multivariate trigonometric polynomial up to an explicit normalization. The circuit processes one variable coherently over the frequency components of the remaining variables, allowing all components to share the same signal queries. Each variable is queried exactly as many times as its degree in the polynomial, and we prove that this query complexity is optimal. We further extend the construction to commuting unitaries. The resulting circuit applies the multivariate polynomial simultaneously across their shared eigenbasis, using the minimum numbers of forward and inverse queries to each unitary. We also study trainable rotations with fixed preparation and a local readout of the last input. At query depth at least two, independent uniform initialization gives every active readout gradient a variance lower bound set by its squared branch weight and the inverse square root of the depth, uniformly over data states and dimensions. For supervised squared loss, retaining sample correlations gives an initialization gradient-variance bound in terms of targets and input spectra. This also bounds the expected loss decrease after the first exact gradient step with a specified step size. These results provide a scalable and practical solution for developing multivariate quantum algorithms and quantum learning models.

quant-pharXiv:2610.03393•Oct 5, 2026•0 citations

Parallel Quantum Signal Processing Via Polynomial Factorization

John M. Martyn, Zane M. Rossi, Kevin Z. Cheng +2 more

Quantum signal processing (QSP) is a methodology for constructing polynomial transformations of a linear operator encoded in a unitary. Applied to an encoding of a state ρ , QSP enables the evaluation of nonlinear functions of the form tr(P(ρ)) for a polynomial P(x) , which encompasses relevant properties like entropies and fidelity. However, QSP is a sequential algorithm: implementing a degree- d polynomial necessitates d queries to the encoding, equating to a query depth d . Here, we reduce the depth of these property estimation algorithms by developing Parallel Quantum Signal Processing. Our algorithm parallelizes the computation of tr(P(ρ)) over k systems and reduces the query depth to d/k , thus enabling a family of time-space tradeoffs for QSP. This furnishes a property estimation algorithm suitable for distributed quantum computers, and is realized at the expense of increasing the number of measurements by a factor O(poly(d)2O(k)) . We achieve this result by factorizing P(x) into a product of k smaller polynomials of degree O(d/k) , which are each implemented in parallel with QSP, and subsequently multiplied together with a swap test to reconstruct P(x) . We characterize the achievable class of polynomials by appealing to the fundamental theorem of algebra, and demonstrate application to canonical problems including entropy estimation and partition function evaluation.

arXiv:2409.19043•Quantum•Aug 27, 2025•2 citations
We present EHands, a quantum-native protocol for implementing multivariable polynomial transformations on quantum processors. The protocol introduces four fundamental, reversible operators: multiplication, addition, negation, and parity flip, and employs the Expectation Value ENcoding (EVEN) scheme to represent real numbers as quantum states. Unlike discretization or binary encoding methods, EHands operates directly on vectorized real-valued inputs prepared in the initial state and applies a shallow quantum circuit that depends only on the polynomial coefficients. The result is obtained from the expectation value measured on a single qubit, enabling efficient parallel evaluation of a polynomial across multiple data points using a single circuit. We introduce both a reversible implementation for degree-ddd polynomials, requiring 3d3d3d qubits, and a non-reversible variant that uses qubit resets to reduce the requirements to d+1d+1d+1 qubits. Both implementations exhibit linear depth scaling in ddd and are explicitly decomposed into one- and two-qubit gates for direct execution on current quantum processing units. The protocol's effectiveness is demonstrated through experimental validation on IBM's Heron-class quantum processors, showing reliable polynomial approximations of functions like ReLU and arctan.
Efficiently uploading data into quantum states is essential for many quantum algorithms to achieve advantage across various applications. In this paper, we address this challenge by developing a method to upload a polynomial function f ( x ) on the interval x ∈ [ − 1 , 1 ] into a pure quantum state consisting of qubits, where a discretized f ( x ) is the amplitude of this state. The preparation cost has O ( n log n ) scaling in the number of qubits n and linear scaling with the degree of the polynomial Q . This efficiency allows the preparation of states whose amplitudes correspond to high-degree polynomials (up to 10 4 ), enabling accurate approximation of functions that admit efficient polynomial series representations and whose amplitude profiles are not extremely localized. We provide a fully explicit circuit realization, based on four real polynomials that meet specific parity and boundedness conditions. We extend this construction to cover piecewise polynomial functions, a case not previously addressed explicitly in the literature, the algorithm scaling linearly with the number of piecewise parts. Our method achieves efficient quantum circuit implementation and we present detailed gate counting and resource analysis.
Quantum circuits naturally implement unitary operations on input quantum states. However, non-unitary operations can also be implemented through "block encodings", where additional ancilla qubits are introduced and later measured. While block encoding underlies a host of well-established theoretical applications, its implementation in practice has been prohibitively expensive for current quantum hardware. In this paper, we present practical and explicit block encoding circuits implementing matrix polynomial transformations of a target matrix. With standard approaches, block-encoding a degree-d matrix polynomial requires a circuit depth scaling as d times the depth for block-encoding the original matrix alone. By leveraging the recently introduced Fast One-Qubit Controlled Select Linear Combination of Unitaries (FOQCS-LCU) framework, we show that the additional circuit-depth overhead required for encoding matrix polynomials can be reduced to scale linearly in d with no dependence on system size or the cost of block encoding the original matrix. Moreover, we demonstrate that the FOQCS-LCU circuits and their associated matrix polynomial transformations can be controlled with negligible overhead, enabling efficient applications such as Hadamard tests. Finally, we provide explicit hardware-efficient circuits for representative non-unitary operators, namely quantum spin models, together with detailed non-asymptotic gate counts and circuit depths.
Quantum state preparation is a central primitive in many quantum algorithms, yet it is generally resource intensive, with efficient constructions known only for structured families of states. This work introduces a method for preparing quantum states whose amplitudes are given by a degree−d-d−d polynomial, using circuits with logarithmic depth in the number nnn of qubits and only O(n)\mathcal O(n)O(n) ancilla qubits, improving previous approaches that required linear-depth circuits. The construction first relies on a block-encoding of an affine diagonal operator based on its Pauli-basis decomposition, which involves only nnn terms. A modified linear-combination-of-unitaries (LCU) technique is introduced to implement this decomposition in logarithmic depth, together with a novel circuit for the EXACT-one oracle that flags basis states in which exactly one qubit is in the state ∣1⟩|1\rangle∣1⟩. It then uses a generalized quantum eigenvalue transformation (GQET) to promote this affine operator to an arbitrary degree polynomial. Theoretical analysis and numerical simulations are reported along with a proof-of-principle implementation on a trapped-ion quantum processor using 141414 qubits and more than 500500500 primitive quantum gates. Because polynomial approximations are ubiquitous in scientific computing, this construction provides a scalable and resource-efficient approach to quantum state preparation, further improving the potential of quantum algorithms in fields such as chemistry, physics, engineering, and finance.
Loading functions into quantum computers represents an essential step in several quantum algorithms, such as quantum partial differential equation solvers. Therefore, the inefficiency of this process leads to a major bottleneck for the application of these algorithms. Here, we present and compare two efficient methods for the amplitude encoding of real polynomial functions on n qubits. This case holds special relevance, as any continuous function on a closed interval can be uniformly approximated with arbitrary precision by a polynomial function. The first approach relies on the matrix product state representation (MPS). We study and benchmark the approximations of the target state when the bond dimension is assumed to be small. The second algorithm combines two subroutines. Initially we encode the linear function into the quantum registers either via its MPS or with a shallow sequence of multi-controlled gates that loads the linear function's Hadamard-Walsh series, and we explore how truncating the Hadamard-Walsh series of the linear function affects the final fidelity. Applying the inverse discrete Hadamard-Walsh transform converts the state encoding the series coefficients into an amplitude encoding of the linear function. Thus, we use this construction as a building block to achieve an exact block encoding of the amplitudes corresponding to the linear function on k0 qubits and apply the quantum singular value transformation that implements a polynomial transformation to the block encoding of the amplitudes. This unitary together with the Amplitude Amplification algorithm will enable us to prepare the quantum state that encodes the polynomial function on k0 qubits. Finally we pad n−k0 qubits to generate an approximated encoding of the polynomial on n qubits, analyzing the error depending on k0 . In this regard, our methodology proposes a method to improve the state-of-the-art complexity by introducing controllable errors.
Polynomial transformations of data encoded in quantum operations are a building block of quantum algorithms, and their query complexity measures how often those operations are used. For multiple variables, existing methods either realize restricted polynomial families or implement monomials separately at a query cost exponential in the number of variables. We present a quantum circuit that implements every multivariate trigonometric polynomial up to an explicit normalization. The circuit processes one variable coherently over the frequency components of the remaining variables, allowing all components to share the same signal queries. Each variable is queried exactly as many times as its degree in the polynomial, and we prove that this query complexity is optimal. We further extend the construction to commuting unitaries. The resulting circuit applies the multivariate polynomial simultaneously across their shared eigenbasis, using the minimum numbers of forward and inverse queries to each unitary. We also study trainable rotations with fixed preparation and a local readout of the last input. At query depth at least two, independent uniform initialization gives every active readout gradient a variance lower bound set by its squared branch weight and the inverse square root of the depth, uniformly over data states and dimensions. For supervised squared loss, retaining sample correlations gives an initialization gradient-variance bound in terms of targets and input spectra. This also bounds the expected loss decrease after the first exact gradient step with a specified step size. These results provide a scalable and practical solution for developing multivariate quantum algorithms and quantum learning models.
Quantum signal processing (QSP) is a methodology for constructing polynomial transformations of a linear operator encoded in a unitary. Applied to an encoding of a state ρ , QSP enables the evaluation of nonlinear functions of the form tr(P(ρ)) for a polynomial P(x) , which encompasses relevant properties like entropies and fidelity. However, QSP is a sequential algorithm: implementing a degree- d polynomial necessitates d queries to the encoding, equating to a query depth d . Here, we reduce the depth of these property estimation algorithms by developing Parallel Quantum Signal Processing. Our algorithm parallelizes the computation of tr(P(ρ)) over k systems and reduces the query depth to d/k , thus enabling a family of time-space tradeoffs for QSP. This furnishes a property estimation algorithm suitable for distributed quantum computers, and is realized at the expense of increasing the number of measurements by a factor O(poly(d)2O(k)) . We achieve this result by factorizing P(x) into a product of k smaller polynomials of degree O(d/k) , which are each implemented in parallel with QSP, and subsequently multiplied together with a swap test to reconstruct P(x) . We characterize the achievable class of polynomials by appealing to the fundamental theorem of algebra, and demonstrate application to canonical problems including entropy estimation and partition function evaluation.