⚛️ quantum physics

Harmonic sequence state-preparation

This paper presents an efficient quantum circuit that prepares a state with harmonic sequence amplitudes by first generating a state with linearly related amplitudes and then applying a quantum Fourier transform, a method that also extends to block-encoding matrices with harmonic diagonals.

Original authors: Benjamin Rempfer, Parker Kuklinski, Justin Elenewski, Kevin Obenland

Published 2026-03-02

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Benjamin Rempfer, Parker Kuklinski, Justin Elenewski, Kevin Obenland

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

Imagine you are a chef trying to bake a very specific, complex cake. In the world of quantum computers, this "cake" is a quantum state—a special arrangement of information that algorithms need to solve difficult problems, like predicting weather patterns or simulating chemical reactions.

Usually, baking this specific cake (creating a "harmonic sequence" where the ingredients follow a pattern like 1/1, 1/2, 1/3, 1/4...) is incredibly hard. It's like trying to measure out exactly 1/1,000,000th of a gram of sugar using a standard kitchen scale. Most existing methods are slow, require massive amounts of extra equipment (ancilla qubits), and waste a lot of energy (computational cost).

This paper introduces a clever new recipe that makes this process fast, efficient, and surprisingly simple. Here is how they did it, explained through everyday analogies:

1. The Problem: The "Sawtooth" vs. The "Harmonic"

The authors wanted to create a quantum state where the "flavor" (amplitude) of each ingredient drops off like a harmonic sequence ( $1/x$ ).

Old Way: Trying to calculate $1/x$ directly is like trying to build a staircase where every step gets infinitely smaller. It requires complex math, lots of errors, and huge resources.
The Insight: The authors realized that if you look at a sawtooth wave (a shape that goes up linearly and then drops sharply), its "Fourier coefficients" (the hidden musical notes that make up the wave) naturally follow the harmonic sequence they wanted.

2. The Solution: The "Magic Mirror" (Quantum Fourier Transform)

Instead of trying to build the harmonic sequence from scratch, they decided to build the sawtooth wave first.

Step 1: Build the Ramp. They created a "linear state," which is like a ramp where the height increases steadily (1, 2, 3, 4...). This is very easy to build in a quantum computer.
Step 2: The Magic Mirror. They passed this ramp through a Quantum Fourier Transform (QFT). Think of the QFT as a magical prism or a mirror. When you shine a sawtooth wave through it, the mirror reflects the hidden "notes" of the wave.
The Result: Because of the math of waves, the reflection (the output) naturally looks like the harmonic sequence ( $1, 1/2, 1/3...$ ) they needed!

3. The "Cotangent" Glitch and the Fix

There was a small catch. Because quantum computers work with discrete steps (like pixels on a screen) rather than smooth lines, the mirror didn't produce a perfect harmonic sequence immediately. It produced something that looked like a cotangent function (a curve that shoots up to infinity at the edges).

The Analogy: Imagine trying to draw a smooth curve using a pixelated video game. Near the edges, the pixels look jagged and weird.
The Fix: The authors realized that if they made the "ramp" (the input) much larger (adding more "pixels" or qubits), the jagged edges of the cotangent curve would move further away, and the middle part would look almost perfectly like the smooth harmonic sequence they wanted. They essentially "zoomed in" on the perfect part of the curve and ignored the messy edges.

4. Why This Matters: The "Block-Encoding"

In quantum computing, we often need to put these sequences into a matrix (a grid of numbers) to solve differential equations (math that describes how things change over time, like fluid flow).

The Old Problem: Previous methods to put this sequence into a matrix were so expensive that they would slow down the entire computer.
The New Trick: Because they used the "Magic Mirror" (QFT) to create the state, they could use a mathematical rule called the Convolution Theorem.
- Analogy: If you want to mix two flavors, you can either mix them in the bowl (time domain) or mix their "flavor profiles" in a blender (frequency domain). The authors realized that mixing the "sawtooth profile" with a simple matrix was equivalent to multiplying by the harmonic sequence.
- This allowed them to create the complex matrix without doing the heavy lifting of calculating $1/x$ for every single number.

5. The Result: A Massive Efficiency Boost

The paper compares their new method to the old "Rejection Sampling" method (which is like throwing darts at a board until you hit the bullseye).

Old Method: Took about 11,000 complex operations (Toffoli gates) to get the result.
New Method: Takes only about 5,400 operations, and the "depth" (how long the computer has to run) is reduced to just 1,700.

The Bottom Line

The authors didn't try to force the quantum computer to do hard arithmetic. Instead, they used the natural properties of waves (specifically, how a sawtooth wave turns into a harmonic sequence when you look at it through a Fourier lens).

By building a simple "ramp" and letting the quantum computer's natural "mirror" do the heavy lifting, they turned a resource-heavy, error-prone task into a streamlined, efficient process. This means that future quantum computers can solve complex physics and engineering problems much faster than previously thought possible.

1. Problem Statement

The paper addresses the challenge of efficiently preparing quantum states and block-encodings where the amplitudes or matrix entries follow a harmonic sequence ( $1/x$ ). Specifically, the target state is defined as:
$|h\rangle \propto \sum_{x=1}^{N-1} \frac{1}{x}|x\rangle$
and the target matrix is a diagonal matrix with these harmonic entries.

Context and Challenges:

Importance: Harmonic sequences are critical components in quantum algorithms for solving nonlinear differential equations (e.g., via Carleman linearization) and other scientific computing tasks.
Limitations of Existing Methods:
- Grover-Rudolph: Struggles because $1/x$ is not integrable near zero.
- Polynomial Approximation (QSVT): Fails because $1/x$ has a singularity, making it difficult to approximate with polynomials over the full domain.
- Rejection Sampling (Lemieux et al.): Requires thousands of Toffoli gates and large ancilla registers, resulting in high resource overhead.
- Newton's Method: Incurs large overheads as error tolerance decreases.
Goal: Develop a method that avoids cumbersome binary arithmetic and leverages natural quantum operations to achieve significantly lower resource costs (specifically T-depth and T-count).

2. Methodology

The authors propose a novel approach based on harmonic analysis and the Quantum Fourier Transform (QFT), exploiting the mathematical relationship between sawtooth waves and harmonic series.

A. Harmonic Sequence State Preparation

Mathematical Insight: The Fourier coefficients of a sawtooth wave follow a harmonic sequence ( $1/k$ ). In the discrete quantum domain, the QFT of a "linear state" (amplitudes proportional to $x$ ) yields a state with amplitudes following a cotangent function:
$\text{QFT}|L\rangle \propto \sum \left(1 + i \cot\left(\frac{\pi k}{N}\right)\right)|k\rangle$
Approximation Strategy: Near the singularity (small $k$ ), $\cot(x) \approx 1/x$ . The authors observe that the asymptotes of this cotangent state closely approximate the desired harmonic sequence.
Circuit Construction:
- Step 1: Prepare a "linear state" $|L\rangle$ with amplitudes linearly scaling with the index. This is done efficiently using controlled-SWAP gates and errorless rotation states, avoiding expensive arithmetic.
- Step 2: Apply the QFT to $|L\rangle$ to generate the cotangent state.
- Step 3: Asymptote Extraction. Since the discrete QFT produces two asymptotes (one approximating $1/x$ $1/ x$ and another a "reversed" version), the circuit uses ancilla qubits and coherent operations (CNOTs, multi-controlled X gates, and incrementers) to:
  - Eliminate the non-trivial amplitude at the singularity.
  - Reverse the order of the second asymptote.
  - Coherently interfere the two asymptotes to cancel the constant real part and amplify the imaginary harmonic part.
- Result: A state $|h\rangle$ with high fidelity to the harmonic sequence.

B. Harmonic Sequence Block-Encoding

To use this in differential equation solvers, the harmonic sequence must be encoded into a matrix diagonal.

Convolution Theorem: The authors utilize the property that convolution in the time domain corresponds to multiplication in the frequency domain.
Circulant Matrix: They define a linear circulant matrix $C$ whose eigenvalues (after QFT) correspond to the harmonic sequence.
Circuit:
- Block-encode the linear circulant matrix $C$ .
- Conjugate this block-encoding with QFT and inverse QFT: $\text{QFT} \cdot C \cdot \text{QFT}^\dagger$ .
- This transforms the circulant matrix into a diagonal matrix containing the harmonic sequence.
- A cyclic shift operator moves the sequence to the required subdiagonal position for differential equation applications.

3. Key Contributions

QFT-Based Algorithm: Introduced the first efficient circuit for preparing harmonic sequence states and block-encodings by leveraging the Fourier transform of a sawtooth wave, rather than classical arithmetic or rejection sampling.
Resource Efficiency: Demonstrated that the cost is dominated by the QFT, which is significantly cheaper than the arithmetic-heavy methods previously proposed.
Coherent Asymptote Handling: Developed a technique to coherently combine and filter the two asymptotes of the discrete cotangent function to extract the harmonic sequence with high precision, minimizing the need for post-selection.
Block-Encoding Extension: Extended the state preparation method to block-encode diagonal matrices, a necessary step for applying these states to linear systems in differential equation solvers.

4. Results and Resource Estimates

The paper provides detailed resource counts for a 22-qubit harmonic sequence state with an error tolerance of $\epsilon = 10^{-9}$ .

Metric	Previous Method (Lemieux et al., Rejection Sampling)	This Paper (QFT-based)	Improvement
T-Count	$\approx 11,000$ (Toffoli gates)	$\approx 5,400$	~2x reduction
T-Depth	Not reported (High)	$\approx 1,700$	Significant reduction
Ancilla Qubits	Large registers required	47	Drastic reduction

Dominant Cost: The QFT accounts for 80–90% of the total T-depth and T-count.
Scalability: The expected T-depth scales logarithmically with the number of qubits and linearly with the inverse error tolerance (via rotation synthesis).
Block-Encoding: For a diagonal harmonic block-encoding, the QFT components account for ~82% of the T-depth. The subnormalization factor is $\alpha \approx 0.1061$ .

5. Significance and Implications

Nonlinear Differential Equations: The harmonic sequence block-encoding is a bottleneck in quantum algorithms for nonlinear differential equations (e.g., fluid dynamics). By reducing the cost of this subroutine, the overall algorithm becomes more feasible.
Bottleneck Analysis: In a computational fluid dynamics example (Carleman linearization with $K=3$ ), the cost of the harmonic sequence block-encoding (~5,300 T-gates) is negligible compared to the cost of block-encoding the system matrices $F_0, F_1, F_2$ (which cost $10^4$ to $10^7$ T-gates). This confirms that the harmonic sequence is not the dominant cost in the pipeline, validating the efficiency of the proposed method.
Generalizability: The authors suggest this QFT-based approach can be extended to other difficult-to-prepare states where the target is the Fourier transform of an easily preparable state (e.g., inverse monomials $x^{-n}$ or sinc states).

Conclusion:
The paper successfully demonstrates that exploiting the mathematical structure of the target function (via the Fourier transform of a sawtooth wave) yields a quantum state preparation method that is orders of magnitude more efficient than generic rejection sampling or arithmetic-based approaches. This makes the implementation of harmonic sequence-dependent quantum algorithms, particularly for nonlinear differential equations, significantly more practical for fault-tolerant quantum computers.