⚛️ quantum physics

Quantum State Preparation for Complex-Valued Amplitudes

This paper presents a quantum state preparation method that utilizes the CORDIC algorithm to convert binary representations of real and imaginary components into complex-valued amplitudes with $O(n^2)$ T-gate complexity and $O(n)$ ancilla qubits, offering improved normalization efficiency and retained polar data for subsequent arithmetic compared to Linear Combination of Unitaries (LCU) approaches.

Original authors: Fred Sun

Published 2026-10-28

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Fred Sun

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the realm of quantum computing, scientists are constantly searching for ways to make machines that operate on the strange laws of the very small solve problems that are impossible for today's supercomputers. These machines, which use particles like atoms or electrons to process information, rely on a fundamental concept called a quantum state. Think of this state as a container holding a specific amount of information, where the value of that information is not just a simple number, but a complex mixture of possibilities existing all at once. To make these machines useful for tasks like simulating new materials or understanding the behavior of atoms, researchers must be able to load specific numbers into these containers. However, a significant hurdle exists: while quantum computers can easily store numbers as sequences of zeros and ones, just like a standard computer, they struggle to turn those simple sequences into the complex, multi-layered values needed for advanced calculations. This gap between storing a number and actually using it as a building block for a quantum calculation has long been a bottleneck, slowing down progress in fields ranging from chemistry to physics.

A researcher named Fred Sun has proposed a new method to bridge this gap, offering a way to take a complex number—something that has both a real part and an imaginary part, much like a coordinate on a map with two dimensions—and load it directly into the quantum state of a machine. The challenge is that complex numbers are difficult to handle because they require two separate pieces of information to be managed simultaneously. Previous methods tried to load the real and imaginary parts separately and then combine them, but this approach often required a lot of extra resources and introduced inefficiencies that made the process slow and expensive in terms of the computer's energy and time. Sun's work presents a more direct route, a procedure that calculates the size and direction of the number first, and then uses those two values to construct the final quantum state in a single, coherent flow.

The core of this new procedure relies on a technique called CORDIC, which stands for Coordinate Rotation Digital Computer. This is a clever algorithm that has been used for decades in standard electronics to calculate angles and distances, but Sun has adapted it for the quantum world. Instead of using expensive and slow mathematical operations like finding square roots or calculating arctangents, the CORDIC method works by taking a vector, which represents the complex number, and rotating it step-by-step toward a known direction. Imagine a compass needle that is being nudged slightly at a time until it points exactly where it needs to go. In each step of this process, the computer performs simple shifts and additions, which are much faster and easier for a quantum machine to handle than complex division or root-finding. By repeating this rotation many times, the computer can determine the length of the vector and the angle it makes with a reference line with high precision.

Once the computer has determined the length and the angle, it uses these two values to build the desired quantum state. First, it encodes the length into the probability of finding the quantum system in a specific state. Then, it applies a series of gates, which are like tiny switches, to introduce the angle as a phase shift. This phase shift is crucial because it gives the number its "imaginary" character, completing the complex value. What makes this approach particularly powerful is that it does not destroy the original information. Throughout the entire process, the computer keeps the original real and imaginary parts safe in separate registers. After the new state is created, the computer reverses all the steps it took to calculate the length and angle, effectively cleaning up its own workspace and returning all temporary memory to zero. This leaves the original data untouched and the new quantum state ready for use, a process known as being reversible and in-place.

The researchers found that this method is highly efficient. It requires a number of operations that grows with the square of the number of bits used to represent the input, which is a manageable cost for the precision needed. More importantly, the method uses a smaller normalization constant than previous techniques. In simpler terms, this means the resulting quantum state is closer to the ideal value without needing as much extra "boosting" to be useful. This reduction in overhead is significant because it lowers the number of times a quantum algorithm needs to repeat a calculation to get a reliable answer. When a calculation involves expensive steps that must be repeated many times, saving even a small amount of resources per step can lead to massive savings in total time and energy. The paper explicitly notes that while other methods might use fewer specific types of logic gates, the overall efficiency gained by having a smaller normalization factor and the ability to perform further arithmetic on the polar representation before encoding makes this new construction superior for many applications.

This work does not claim to have solved every problem in quantum computing, nor does it suggest that the method is perfect for every single scenario. The author is careful to frame their findings as a specific improvement for situations where complex numbers need to be prepared from binary data, particularly in large algorithms like Hamiltonian simulation, which models how energy moves through a system. The paper demonstrates that by computing the magnitude and argument together and then encoding them, one can avoid the inefficiencies of combining separate real and imaginary parts. The result is a state preparation procedure that is coherent, meaning it works correctly even when the input is a mixture of many different possibilities at once, and it preserves the input data for future use. By providing a clear, reversible path from binary digits to complex quantum amplitudes, this research offers a practical tool that could help scientists run more complex simulations and solve harder problems with the quantum computers of the future.

Technical Summary: Quantum State Preparation for Complex-Valued Amplitudes

Problem Statement
Quantum algorithms for scientific computing, such as Hamiltonian simulation and ground-state energy estimation, often require numerical values to be encoded directly into the amplitudes of a quantum state. While quantum arithmetic allows complex numbers $z = x + iy$ to be stored as binary digits in separate registers for the real and imaginary parts, this representation does not inherently encode $z$ as a probability amplitude. Existing methods typically encode the real and imaginary parts separately and combine them using Linear Combination of Unitaries (LCU). However, this approach can result in a large normalization constant, increasing the cost of amplitude amplification. Furthermore, standard arithmetic does not preserve the polar representation ( $r, \phi$ ) of the number, which is often required for subsequent operations like complex inversion. The challenge is to transform binary registers containing $x$ and $y$ into a state where the amplitude approximates $z/\alpha$ (where $\alpha$ is a normalization constant) while preserving the input registers and maintaining coherence for superpositions.

Methodology
The proposed procedure converts the Cartesian representation ( $x, y$ ) into a polar representation ( $r, \phi$ ) reversibly, then encodes these values into the amplitude and phase of a target qubit. The process consists of three main stages:

Reversible Polar Conversion (CORDIC):
The algorithm utilizes the Coordinate Rotation Digital Computer (CORDIC) method to compute the magnitude $r \approx \sqrt{x^2+y^2}$ and argument $\phi \approx \text{atan2}(y, x)$ using only bit-shifts and additions, avoiding expensive square-root and arctan operations.
- Pre-processing: The input vector is mapped to the right half-plane to standardize iteration rules, with an initial angle correction applied based on the quadrant.
- Iteration: $n$ iterations are performed on working registers. In each step $j$ , the vector is rotated by a precomputed angle $\alpha_j = \arctan(2^{-j})$ based on the sign of the $y$ -coordinate. The updates involve reversible ripple-carry adders and controlled sign-flips (using S2C conversion).
- Precision Management: To handle rounding errors from fixed-point arithmetic, the algorithm employs $O(\log n)$ additional fractional bits. A reversible in-place multiplier clears temporary workspace after coordinate updates, ensuring the original inputs remain intact for uncomputation.
- Magnitude Recovery: After iterations, the final $x$ -coordinate is multiplied by a precomputed gain constant $K_n$ to recover the magnitude $r'$ .
Amplitude and Phase Encoding:
- Magnitude: The computed magnitude $r'$ is normalized by a power-of-two constant $\alpha$ (chosen such that $r < \alpha$ ). This normalized value is encoded into the amplitude of an output register using the AMP procedure (Pocrnic et al.), which maps binary digits to amplitudes.
- Phase: The computed argument $\phi'$ is encoded by applying phase gates $P(2^j)$ to the qubits of the angle register, introducing the factor $e^{i\phi'}$ .
Uncomputation:
Since the arithmetic registers (magnitude and angle) are preserved during encoding, the CORDIC iterations and quadrant corrections are reversed in reverse order. This clears all temporary ancilla qubits and restores the working registers to $|0\rangle$ , leaving the original inputs $|x\rangle|y\rangle$ and the target state $|z'/\alpha\rangle$ .

Key Contributions and Results

Complex Amplitude Preparation: The paper presents a coherent procedure to map binary registers of real and imaginary parts directly into a complex amplitude $z'/\alpha$ , preserving the input registers.
Resource Efficiency: The procedure uses $O(n^2)$ T gates and $O(n)$ additional qubits, where $n$ is the number of bits in the input representation.
Error Bounds: The total error in the reconstructed complex value is bounded by $O(2^{-(n-l)})$ , where $l$ is the number of integer bits. This accounts for rounding errors in CORDIC iterations, gain multiplication, and phase gate synthesis.
Polar Representation Utility: Unlike LCU-based approaches, this method explicitly computes and retains the polar representation ( $r, \phi$ ) before encoding. This allows for further arithmetic operations (e.g., computing reciprocals via $r^{-1}e^{-i\phi}$ ) before the final amplitude encoding.

Significance and Claims
The author claims that this construction offers a potential advantage over separately encoding real and imaginary parts via LCU. While LCU may use fewer Toffoli gates asymptotically, the proposed method can achieve a smaller normalization constant $\alpha$ . A smaller $\alpha$ increases the success probability of the state preparation, thereby reducing the number of amplitude-amplification steps required. This resource saving is particularly significant when the input computations are expensive and repeated during each amplification step. Additionally, the availability of the polar representation enables efficient implementation of complex arithmetic operations (such as inversion) that are difficult to perform directly on Cartesian-encoded amplitudes. The paper positions this as a modular component for larger quantum algorithms rather than a standalone experimental proposal.

Technical Summary: Quantum State Preparation for Complex-Valued Amplitudes

More like this