⚛️ quantum physics

Worst-case Harrow-Hassidim-Lloyd algorithm with average-case correct quantum Fourier transform

This paper demonstrates that the Harrow-Hassidim-Lloyd algorithm can achieve provably good worst-case performance across three distinct scenarios by leveraging a strengthened protocol that relies solely on the average-case correctness of the quantum Fourier transform.

Original authors: Changpeng Shao

Published 2026-04-14

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Changpeng Shao

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

The Big Picture: The "Good Enough" Quantum Chef

Imagine you are trying to bake a very complex cake (solving a difficult math problem) using a high-tech, temperamental oven (a quantum computer). The recipe requires a specific, perfect ingredient: the Quantum Fourier Transform (QFT). Think of the QFT as a magical spice grinder that turns raw ingredients into the perfect powder needed for the cake.

The Problem:
Real quantum computers are noisy. They are like ovens that sometimes burn the bread or forget to preheat. We can't always guarantee that the spice grinder works perfectly every single time (this is called "worst-case" performance). Checking if it works perfectly every time is incredibly hard, expensive, and slow.

However, checking if the grinder works most of the time (on average) is easy and fast.

The Previous Discovery:
A few years ago, researchers Linden and de Wolf discovered a clever trick. They proved that if your spice grinder works well on average, it's actually good enough to bake a perfect cake for many standard recipes (like finding patterns or estimating phases).

The New Discovery (This Paper):
The author, Changpeng Shao, asks: "What about the Harrow-Hassidim-Lloyd (HHL) algorithm?"

The HHL algorithm is like a very fancy, delicate soufflé. It doesn't just need the right ingredients; it needs them to be mixed with perfect timing and phase. If the spice grinder is slightly off, it doesn't just make the cake taste bad; it adds a weird "ghost flavor" (a random phase shift) that ruins the texture entirely. The previous "good on average" trick wasn't strong enough for this delicate soufflé.

The Solution:
Shao says, "Let's upgrade the test!"

He proposes a strengthened protocol. Instead of just checking if the grinder works on random single ingredients, we check if it works on pairs of ingredients and how they relate to each other.

The Old Test: "Does the grinder turn 90% of single apples into apple powder?"
The New Test: "Does the grinder turn 90% of apple pairs into powder while keeping the relationship between the two apples intact?"

The Three Scenarios (The "How-To")

The paper shows that if your quantum computer passes this new, stricter "average" test, you can run the HHL algorithm (the soufflé) successfully, even if the machine is imperfect. They prove this works in three different situations:

The "Double-Check" Scenario:
Imagine you have a machine that claims to be the spice grinder. You test it by feeding it random ingredients and seeing if the output is correct. But to be sure it's not just getting lucky, you also test it by feeding it the reverse of the ingredients. If it passes both tests, you know it's reliable enough to bake the soufflé.
The "Invertible" Scenario:
What if you have a machine that is a bit broken, but you also have a machine that can undo whatever the first one does? If you run the ingredient through the broken machine and then immediately through the "undo" machine, and the result is still good on average, you can still bake the cake. This is like having a broken translator and a perfect reverse-translator; if the message comes back clear, you're good.
The "Partnership" Scenario:
Sometimes you have two different machines: one that does the grinding and one that does the un-grinding. Even if neither is perfect on its own, if they work well together (their combined average performance is high), they can still produce the perfect soufflé.

Why Does This Matter?

1. It's Cheaper and Faster:
Verifying that a quantum computer works perfectly 100% of the time is like trying to prove a coin is fair by flipping it a billion times. It's impossible. Verifying it works "on average" is like flipping it 100 times. This paper proves that for the most important quantum algorithm (HHL), the "100 flips" test is actually sufficient.

2. It Makes Quantum Computers More Practical:
Right now, quantum computers are noisy. We can't wait for them to be perfect before we use them. This research gives us a "green light" to use current, imperfect machines for solving complex linear equations (which is huge for machine learning and engineering), provided we run this simple, lightweight check first.

The Takeaway

Think of this paper as a quality control manual for a noisy factory.

Previously, we thought: "If the machine isn't perfect every single time, we can't use it for delicate work."
Shao says: "No! If we check the machine in a slightly smarter way (looking at how pairs of items interact), we can prove it's reliable enough to do the delicate work, even if it's not perfect."

This means we can start using quantum computers to solve real-world problems (like optimizing traffic, designing new drugs, or training AI) much sooner than we thought, without waiting for perfect hardware.

1. Problem Statement

The paper addresses the challenge of quantum verification, specifically ensuring the reliability of the Quantum Fourier Transform (QFT) in practical quantum computing scenarios.

The Context: The QFT is a fundamental component of many quantum algorithms, including Shor's algorithm and the Harrow-Hassidim-Lloyd (HHL) algorithm for solving linear systems.
The Limitation of Existing Work: Linden and de Wolf (2022) proposed a lightweight protocol to verify the average-case correctness of the QFT. They proved that good average-case performance suffices for worst-case performance in tasks like phase estimation and period finding.
The Gap: The HHL algorithm requires more than just correct eigenvalue estimation; it requires outputting a specific quantum state dependent on both eigenvalues and eigenvectors. A QFT that is correct on average (in the sense of Linden-de Wolf) might introduce uncontrollable local phases (diagonal unitary errors) that are invisible to average-case fidelity checks but catastrophic for the final state of HHL. Specifically, if the QFT is $C = D F_N^{-1}$ (where $D$ is an unknown diagonal unitary), it passes average-case tests but produces a state with random phases, rendering the HHL output useless.
Goal: To determine if the HHL algorithm can be executed with provably good worst-case performance assuming only that the QFT is correct on average, by strengthening the verification protocol.

2. Methodology

The author introduces a strengthened verification protocol and defines new sets of quantum channels to bridge the gap between average-case verification and worst-case HHL execution.

A. Strengthened Verification Sets

The paper defines three sets of quantum channels close to the inverse QFT ( $F_N^{-1}$ ):

$S_1(\eta)$ : Channels close to $F_N^{-1}$ on the Fourier basis (standard average-case definition).
$\mathbb{E}_k [F(C(|\hat{k}\rangle\langle\hat{k}|), |k\rangle\langle k|)] \geq 1 - \eta$
$S_2(\eta)$ : Channels close to $F_N^{-1}$ on the computational basis (testing $C$ against $F_N^{-1}$ acting on computational states).
$\mathbb{E}_k [F(C(|k\rangle\langle k|), |-\hat{k}\rangle\langle-\hat{k}|)] \geq 1 - \eta$
$S_3(\eta)$ (The Key Contribution): Channels that preserve the coherence between Fourier basis states and computational basis states.
$\mathbb{E}_{k,l} [\langle k| C(|\hat{k}\rangle\langle\hat{l}|) |l\rangle] \geq 1 - \eta$

Key Insight: The paper proves that if a channel $C$ satisfies both $S_1(\eta)$ and $S_2(\eta)$ , it automatically satisfies $S_3(\eta)$ .

$S_3(\eta)$ Implication: This condition ensures that the channel acts as a global phase rotation (plus small errors) rather than introducing uncontrollable local phases. This is the necessary condition for HHL.

B. Lightweight Testing Protocols

To verify membership in these sets without full tomography (which is exponentially hard), the paper proposes two lightweight testing algorithms:

TA1: Tests $S_1(\eta)$ by preparing $|\hat{k}\rangle$ , applying $C$ , and measuring in the computational basis.
TA2: Tests $S_2(\eta)$ by preparing $|k\rangle$ , applying $H^{\otimes n} U_k C$ , and measuring in the computational basis (checking if the result is $|0\rangle^{\otimes n}$ ).
Result: Running TA1 and TA2 allows one to verify $C \in S_1(\eta) \cap S_2(\eta)$ , which implies $C \in S_3(2\eta)$ .

C. Application to HHL

The HHL algorithm is analyzed by replacing the ideal $F_N^{-1}$ and $F_N$ with noisy channels $C$ and $P$ (where $P$ is verified to be close to $F_N$ ). The analysis uses randomization (shifting eigenvalues by a random $l$ ) to average out errors and prove that the final state remains close to the ideal target state in terms of fidelity.

3. Key Contributions

Strengthened Protocol: The paper extends the Linden-de Wolf protocol by adding a second test (TA2) to verify coherence across bases, ensuring the channel does not introduce destructive local phases.
Worst-Case HHL with Average-Case QFT: It is proven that if the QFT passes the strengthened average-case tests, the HHL algorithm produces a state with high fidelity to the ideal solution, even in the worst-case scenario regarding the input matrix.
Generalization to Unitary Channels: The paper provides specific, tighter bounds for the case where the noisy channel is a unitary, offering more concise results (Theorems 14–18).
Handling Non-Exact Eigenvalues: The analysis covers the general case where eigenvalues are not exactly representable by $n$ bits, introducing error bounds dependent on the approximation parameter $K$ .

4. Main Results

The paper presents several theorems quantifying the fidelity of the output state $\rho_{7,l}$ compared to the ideal state $|\phi_{7,l}\rangle$ :

Theorem 10 (Exact Eigenvalues): If $C \in S_3(\eta_1)$ and $P \in T_3(\eta_2)$ , the average fidelity is:
$\mathbb{E}_l [F(\rho_{7,l}, |\phi_{7,l}\rangle\langle\phi_{7,l}|)] \geq 1 - \sqrt{\eta_1} - \sqrt{\eta_2}$
This confirms that small average-case errors ( $\eta$ ) lead to small worst-case fidelity loss.
Theorem 13 (General Case): For eigenvalues approximated by $K$ bits, the fidelity bound includes terms for the approximation error and the channel noise:
$\text{Fidelity} \geq 1 - (\eta_1^{1/2} + \eta_2^{1/2}) - 2\sqrt{K}(\eta_1^{1/4} + \eta_2^{1/4}) - \frac{4\sqrt{5}}{(K-1)^{1/4}}$
Theorems 14 & 15 (Unitary with Inverse): If the channel $C$ is unitary and its inverse $C^{-1}$ is available, the error bounds are significantly tighter (scaling with $\sqrt{\eta}$ ).
Theorems 17 & 18 (Unitary without Inverse): If $C$ and $P$ are unitary but their inverses are not available, an additional condition $|\mathbb{E}_k[\langle k|C \circ P|k\rangle]| \geq 1 - \eta_3$ is required to ensure the phases cancel out.

5. Significance

Feasibility of NISQ-era HHL: The results suggest that the HHL algorithm, a cornerstone of quantum machine learning and linear algebra, can be robustly executed even if the underlying QFT hardware is imperfect, provided the imperfections are "average-case correct" and verified via the proposed lightweight protocols.
Efficiency: The verification protocols (TA1 and TA2) are lightweight, requiring only $O(\eta^{-2} \log(1/\delta))$ runs, making them practical for near-term quantum devices where full tomography is impossible.
Theoretical Bridge: The work successfully bridges the gap between average-case verification (which is easy) and worst-case algorithmic performance (which is hard), specifically for algorithms requiring coherent state manipulation rather than just eigenvalue extraction.
Future Directions: The authors suggest this "worst-case-to-average-case" reduction paradigm can be applied to other QFT-based algorithms, such as quantum tomography and other phase-estimation-heavy routines.

In summary, Changpeng Shao demonstrates that by strengthening the verification criteria for the QFT, one can guarantee the correctness of the HHL algorithm in the worst case, relying solely on efficient, average-case verification tests. This significantly lowers the barrier for implementing HHL on noisy intermediate-scale quantum (NISQ) devices.