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:2610.36680

Quantum State Preparation for Complex-Valued Amplitudes

Fred Sun

quant-phSubmitted Oct 27, 2026• Announced Oct 28, 2026• 0 citations
arXivHTMLPDF

Abstract

We present a state preparation procedure that takes binary registers containing the real and imaginary parts of a complex number $z=x+iy$ and prepares an amplitude approximating $z/α$, where $α$ is a normalization constant. The magnitude and argument are computed using the Coordinate Rotation Digital Computer (CORDIC) algorithm. We then encode the magnitude into an amplitude, and apply phase gates to introduce the argument. A reversible in-place multiplier allows the coordinate updates to use fixed precision while clearing their temporary workspace. The procedure uses $O(n^2)$ $T$ gates and $O(n)$ additional qubits. Compared with separately encoding the real and imaginary parts and combining them through LCU, the construction can allow a smaller normalization and reduce amplitude-amplification costs. The computed polar representation also remains available for further arithmetic before amplitude-encoding.

AI Summary

The paper considers coherent conversion of binary-encoded real and imaginary parts of $z=x+iy$ into a complex amplitude, while preserving the inputs and clearing arithmetic workspace. Its target transformation has a designated output amplitude $z'/\alpha$, where $z'$ approximates $z$ and $\alpha$ is a power-of-two normalization bound. The construction computes magnitude and argument using $n$ reversible CORDIC iterations, encodes the magnitude with an existing binary-to-amplitude procedure, applies phase gates representing the argument, and reverses the arithmetic. A reversible in-place multiplication by $1+2^{-2j}$ enables sequential coordinate updates without retaining a separate coordinate copy at every iteration. The appendix constructs this multiplier by recovering the original input exactly from the rounded product using structured division. For $n$-bit inputs with $l$ integer bits and one sign bit, the procedure uses $O(n^2)$ $T$ gates and $O(n)$ additional qubits. With $O(\log n)$ extra fractional working bits, the rounding analysis gives $|z'-z|=O(2^{-(n-l)})$. Including phase-gate synthesis, the designated-amplitude error is $O(2^{-(n-l)}/\alpha+2^{-n})$. Separately encoding the real and imaginary parts and combining them through LCU has asymptotically lower Toffoli cost. The proposed construction can instead permit a smaller normalization, potentially reducing amplitude-amplification calls when input computation is expensive; it also exposes the polar representation for further arithmetic. Application-specific resource comparisons and whether these savings outweigh the additional CORDIC cost are left for future work.

Little sign of AI-generated textAI use disclosedIncrementalMissing comparison
ChatGPT was used more extensively during revisions in October 2026 to assist with redrafting and editing the text and checking and formalizing mathematical arguments.

Written by gpt-6.1-sol from the paper's full text. Automated: it can be wrong.

Related papers

Quantum State Preparation without Coherent Arithmetic

Sam McArdle, András Gilyén, Mario Berta

We introduce a versatile method for preparing a quantum state whose amplitudes are given by some known function. Unlike existing approaches, our method does not require handcrafted reversible arithmetic circuits, or quantum table reads, to encode the function values. Instead, we use a template quantum eigenvalue transformation circuit to convert a low-cost block encoding of the sine function into the desired function. Our method uses only four ancilla qubits (three if the approximating polynomial has definite parity), providing order-of-magnitude qubit count reductions compared to state-of-the-art approaches, while using a similar number of gates if the function can be well represented by a polynomial or Fourier approximation. We demonstrate the algorithmic utility of our method, including preparing Gaussian and Kaiser window states.

arXiv:2210.14892•Physical Review Letters•Jun 18, 2026•105 citations

Deterministic and Entanglement-Efficient Preparation of Amplitude-Encoded Quantum Registers

Prithvi Gundlapalli, Junyi Lee

Quantum computing promises to provide exponential speed-ups to certain classes of problems. In many such algorithms, a classical vector $\mathbf{b}$ is encoded in the amplitudes of a quantum state $|b⟩$. However, efficiently preparing $|b⟩$ is known to be a difficult problem because an arbitrary state of $Q$ qubits generally requires approximately ${2}^{Q}$ entangling gates, which results in significant decoherence on today's noisy intermediate-scale quantum (NISQ) computers. We present a deterministic (nonvariational) algorithm that allows us to flexibly reduce the quantum resources required for state preparation in an entanglement-efficient manner. Although this comes at the expense of reduced theoretical fidelity, actual fidelities on current NISQ computers might actually be higher due to reduced decoherence. We show this to be true for various cases of interest, such as the normal and log-normal distributions. For low-entanglement states, our algorithm can prepare states with more than an order of magnitude fewer entangling gates as compared with isometric decomposition.

arXiv:2110.13454•Physical Review Applied•Aug 4, 2022•19 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•55 citations

Quantum state preparation protocol for encoding classical data into the amplitudes of a quantum information processing register's wave function

Sahel Ashhab

We present a protocol for encoding $N$ real numbers stored in $N$ memory registers into the amplitudes of the quantum superposition that describes the state of ${log}_{2}N$ qubits. This task is one of the main steps in quantum machine learning algorithms applied to classical data. The protocol combines partial CNOT gate rotations with probabilistic projection onto the desired state. The number of additional ancilla qubits used during the implementation of the protocol, as well as the number of quantum gates, scales linearly with the number of qubits in the processing register and hence logarithmically with $N$. The average time needed to successfully perform the encoding scales logarithmically with the number of qubits, in addition to being inversely proportional to the acceptable error in the encoded amplitudes. It also depends on the structure of the dataset in such a way that the protocol is most efficient for nonsparse data.

arXiv:2107.14127•Physical Review Research•Feb 3, 2022•36 citations

Efficient Complex-Valued State Preparation on Bucket Brigade QRAM

Alessandro Berti, Francesco Ghisoni

Efficient quantum state preparation is a critical component in quantum algorithms that process large classical data, and it is fundamental to realizing quantum advantage in domains such as machine learning, quantum linear algebra, and quantum finance. Building on the framework of~\cite{berti2025efficient}, which integrates Bucket Brigade QRAM (BBQRAM) with a segment tree to achieve amplitude encoding in polylogarithmic query time, we present two improvements within the same architecture-aware framework. First, we remove the $U_{2\mathrm{CR}}$ subroutine by classically precomputing the rotation angles determined by the segment tree and storing these angles directly in the BBQRAM cells. The tradeoff is that the classically loaded QRAM stores precomputed fixed-point angles rather than raw subtree weights. Second, we extend the construction to complex-valued matrices $A \in \mathbb{C}^{M \times N}$ by storing a leaf phase alongside each precomputed rotation angle and using a two-step magnitude-then-phase procedure; the real signed case is naturally subsumed as a one-bit phase specialization. At unchanged $\mathcal{O}(\log_2^2(MN))$ BBQRAM query complexity, the QPU procedure reduces to BBQRAM retrievals and controlled-rotation cascades, with $\mathcal{O}(MN)$ memory cells per matrix and no reversible arithmetic on the QPU.

quant-pharXiv:2604.25644•Apr 29, 2026•0 citations

Quantum Box-Muller Transform

Dinh-Long Vu, Hitomi Mori, Patrick Rebentrost

The Box-Muller transform is a widely used method to generate Gaussian samples from uniform samples. Quantum amplitude encoding methods encode the multi-variate normal distribution in the amplitudes of a quantum state. This work presents the Quantum Box-Muller transform which creates a superposition of binary-encoded grid points representing the multi-variate normal distribution. The gate complexity of our method depends on quantum arithmetic operations and, using a specific set of known implementations, the complexity is quadratic in the number of qubits. We apply our method to Monte-Carlo integration, in particular to the estimation of the expectation value of a function of Gaussian random variables. Our method implies that the state preparation circuit used multiple times in amplitude estimation requires only quantum arithmetic circuits for the grid points and the function, in addition to a single controlled rotation. We show how to provide the expectation value estimate with an error that is exponentially small in the number of qubits, similar to the amplitude-encoding setting with error-free encoding.

quant-pharXiv:2601.13718•Jan 21, 2026•0 citations
We present a state preparation procedure that takes binary registers containing the real and imaginary parts of a complex number z=x+iyz=x+iyz=x+iy and prepares an amplitude approximating z/αz/αz/α, where ααα is a normalization constant. The magnitude and argument are computed using the Coordinate Rotation Digital Computer (CORDIC) algorithm. We then encode the magnitude into an amplitude, and apply phase gates to introduce the argument. A reversible in-place multiplier allows the coordinate updates to use fixed precision while clearing their temporary workspace. The procedure uses O(n2)O(n^2)O(n2) TTT gates and O(n)O(n)O(n) additional qubits. Compared with separately encoding the real and imaginary parts and combining them through LCU, the construction can allow a smaller normalization and reduce amplitude-amplification costs. The computed polar representation also remains available for further arithmetic before amplitude-encoding.
The paper considers coherent conversion of binary-encoded real and imaginary parts of z=x+iyz=x+iyz=x+iy into a complex amplitude, while preserving the inputs and clearing arithmetic workspace. Its target transformation has a designated output amplitude z′/αz'/\alphaz′/α, where z′z'z′ approximates zzz and α\alphaα is a power-of-two normalization bound.
The construction computes magnitude and argument using nnn reversible CORDIC iterations, encodes the magnitude with an existing binary-to-amplitude procedure, applies phase gates representing the argument, and reverses the arithmetic. A reversible in-place multiplication by 1+2−2j1+2^{-2j}1+2−2j enables sequential coordinate updates without retaining a separate coordinate copy at every iteration. The appendix constructs this multiplier by recovering the original input exactly from the rounded product using structured division.
For nnn-bit inputs with lll integer bits and one sign bit, the procedure uses O(n2)O(n^2)O(n2) TTT gates and O(n)O(n)O(n) additional qubits. With O(log⁡n)O(\log n)O(logn) extra fractional working bits, the rounding analysis gives ∣z′−z∣=O(2−(n−l))|z'-z|=O(2^{-(n-l)})∣z′−z∣=O(2−(n−l)). Including phase-gate synthesis, the designated-amplitude error is O(2−(n−l)/α+2−n)O(2^{-(n-l)}/\alpha+2^{-n})O(2−(n−l)/α+2−n).
Separately encoding the real and imaginary parts and combining them through LCU has asymptotically lower Toffoli cost. The proposed construction can instead permit a smaller normalization, potentially reducing amplitude-amplification calls when input computation is expensive; it also exposes the polar representation for further arithmetic. Application-specific resource comparisons and whether these savings outweigh the additional CORDIC cost are left for future work.
We introduce a versatile method for preparing a quantum state whose amplitudes are given by some known function. Unlike existing approaches, our method does not require handcrafted reversible arithmetic circuits, or quantum table reads, to encode the function values. Instead, we use a template quantum eigenvalue transformation circuit to convert a low-cost block encoding of the sine function into the desired function. Our method uses only four ancilla qubits (three if the approximating polynomial has definite parity), providing order-of-magnitude qubit count reductions compared to state-of-the-art approaches, while using a similar number of gates if the function can be well represented by a polynomial or Fourier approximation. We demonstrate the algorithmic utility of our method, including preparing Gaussian and Kaiser window states.
Quantum computing promises to provide exponential speed-ups to certain classes of problems. In many such algorithms, a classical vector b\mathbf{b}b is encoded in the amplitudes of a quantum state ∣b⟩|b⟩∣b⟩. However, efficiently preparing ∣b⟩|b⟩∣b⟩ is known to be a difficult problem because an arbitrary state of QQQ qubits generally requires approximately 2Q{2}^{Q}2Q entangling gates, which results in significant decoherence on today's noisy intermediate-scale quantum (NISQ) computers. We present a deterministic (nonvariational) algorithm that allows us to flexibly reduce the quantum resources required for state preparation in an entanglement-efficient manner. Although this comes at the expense of reduced theoretical fidelity, actual fidelities on current NISQ computers might actually be higher due to reduced decoherence. We show this to be true for various cases of interest, such as the normal and log-normal distributions. For low-entanglement states, our algorithm can prepare states with more than an order of magnitude fewer entangling gates as compared with isometric decomposition.
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.
We present a protocol for encoding NNN real numbers stored in NNN memory registers into the amplitudes of the quantum superposition that describes the state of log2N{log}_{2}Nlog2​N qubits. This task is one of the main steps in quantum machine learning algorithms applied to classical data. The protocol combines partial CNOT gate rotations with probabilistic projection onto the desired state. The number of additional ancilla qubits used during the implementation of the protocol, as well as the number of quantum gates, scales linearly with the number of qubits in the processing register and hence logarithmically with NNN. The average time needed to successfully perform the encoding scales logarithmically with the number of qubits, in addition to being inversely proportional to the acceptable error in the encoded amplitudes. It also depends on the structure of the dataset in such a way that the protocol is most efficient for nonsparse data.
Efficient quantum state preparation is a critical component in quantum algorithms that process large classical data, and it is fundamental to realizing quantum advantage in domains such as machine learning, quantum linear algebra, and quantum finance. Building on the framework of~\cite{berti2025efficient}, which integrates Bucket Brigade QRAM (BBQRAM) with a segment tree to achieve amplitude encoding in polylogarithmic query time, we present two improvements within the same architecture-aware framework. First, we remove the U2CRU_{2\mathrm{CR}}U2CR​ subroutine by classically precomputing the rotation angles determined by the segment tree and storing these angles directly in the BBQRAM cells. The tradeoff is that the classically loaded QRAM stores precomputed fixed-point angles rather than raw subtree weights. Second, we extend the construction to complex-valued matrices A∈CM×NA \in \mathbb{C}^{M \times N}A∈CM×N by storing a leaf phase alongside each precomputed rotation angle and using a two-step magnitude-then-phase procedure; the real signed case is naturally subsumed as a one-bit phase specialization. At unchanged O(log⁡22(MN))\mathcal{O}(\log_2^2(MN))O(log22​(MN)) BBQRAM query complexity, the QPU procedure reduces to BBQRAM retrievals and controlled-rotation cascades, with O(MN)\mathcal{O}(MN)O(MN) memory cells per matrix and no reversible arithmetic on the QPU.
The Box-Muller transform is a widely used method to generate Gaussian samples from uniform samples. Quantum amplitude encoding methods encode the multi-variate normal distribution in the amplitudes of a quantum state. This work presents the Quantum Box-Muller transform which creates a superposition of binary-encoded grid points representing the multi-variate normal distribution. The gate complexity of our method depends on quantum arithmetic operations and, using a specific set of known implementations, the complexity is quadratic in the number of qubits. We apply our method to Monte-Carlo integration, in particular to the estimation of the expectation value of a function of Gaussian random variables. Our method implies that the state preparation circuit used multiple times in amplitude estimation requires only quantum arithmetic circuits for the grid points and the function, in addition to a single controlled rotation. We show how to provide the expectation value estimate with an error that is exponentially small in the number of qubits, similar to the amplitude-encoding setting with error-free encoding.