Experimental demonstration of the Quantum Fourier Transform on up to 100 qubits using a convolutional compilation strategy

arXiv:2608.05435 · quant-ph · Submitted 2026-08-05 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.

Kai: Today's paper: "Experimental demonstration of the Quantum Fourier Transform on up to 100 qubits using a convolutional compilation strategy".

Mira: This paper presents and experimentally validates a novel "Convolutional QFT" compilation strategy for executing the Quantum Fourier Transform (QFT) subroutine on linear nearest neighbor (LNN) qubit topologies,

Kai: First, who's behind it and why it matters.

Title and authors: Kai: So, shifting gears slightly, we need to talk about who wrote this paper and what exactly this title means for us as an experimental group. We're looking at 'Experimental demonstration of the Quantum Fourier Transform on up to one hundred qubits using a convolutional compilation strategy.'

Mira: The authors are Paul Coote, Michael J. Biercuk, and Yuval Baum from Q-CTRL and Sydney, NSW Australia. They’re experts in quantum control and hardware realization.

Lev: As someone focused on error correction, I'm interested in seeing if these kinds of compilation tricks translate into something practical for running algorithms on actual physical qubits rather than just theoretical circuit diagrams.

Kai: The title itself highlights that they've actually built and measured this—they are demonstrating the QFT on up to one hundred qubits, which is a substantial scale for this kind of circuit.

Mira: The 'convolutional compilation strategy' is the core innovation here; it’s their constructive method for mapping the QFT onto linear nearest neighbor hardware.

Lev: If this strategy holds up under real-world noise conditions, it moves us closer to realizing practical quantum algorithms that aren't limited by perfect connectivity assumptions.

Kai: It’s about taking a difficult problem—QFT on LNN hardware—and finding a specific way to compile it that minimizes resource overhead.

Mira: The implication is that we don't necessarily need a fully connected system to run these kinds of complex functions efficiently; we just need the right compilation tool.

Lev: That really validates the idea that connectivity constraints aren't an absolute barrier for implementing large quantum routines, provided you have a clever way to structure the gates.

Kai: So, they are showing how to build up to one hundred qubits and achieve this with a specific compilation approach on existing hardware.

Mira: It suggests that the efficiency of the overall quantum computation isn't just about having more qubits, but about how you arrange those gates physically.

Lev: I see it as a step toward making larger, more complex simulations feasible on current noisy platforms without immediately requiring full-blown fault tolerance infrastructure.

The paper's summary: Kai: We’ve seen the title and authors, so now let's look at the actual summary of 'Experimental demonstration of the Quantum Fourier Transform on up to one hundred qubits using a convolutional compilation strategy.' They explain what they actually did in this paper.

Mira: They summarize that they introduced two primary strategies: a standard LNN QFT compilation and their novel 'Convolutional AQFT.'

Lev: I'm curious about the summary of the core idea behind that Convolutional AQFT; is it just a slight tweak or a complete overhaul of how they think about gate placement?

Kai: It’s more than a tweak; they claim this variant requires an additional two CX gates in total, realized by a compact, translation-invariant kernel circuit gadget traversing the register.

Mira: The motivation behind this gadget is explicitly to reduce the 'average number of two-qubit gates in the causal history' of each qubit.

Lev: That points toward managing decoherence effects on individual qubits more effectively by controlling how much correlated noise they pick up along their path.

Kai: They then detail the circuit derivation, showing steps like synthesizing Hadamard gates using a phase gate (S) and moving those two phase gates to the front or end of the circuit.

Mira: By moving those S gates around, they can achieve an exact CX parity with the standard all-to-all implementation while operating strictly on an LNN architecture.

Lev: So, they are essentially performing a sophisticated gate rearrangement to achieve the same logical result as a more connected system without needing that extra physical connectivity.

Kai: The paper shows concrete results, mentioning that for n=five their QFT requires twenty CX gates, which is six fewer than the Park/Ahn construction's twenty-six CX gates.

Mira: That comparison with the Park/Ahn construction highlights how much optimization they found in the derivation and how it cuts down on gate count while keeping the quadratic order term intact.

Lev: It’s a good benchmark because it gives us a quantifiable measure of improvement over existing methods for mapping QFT onto restricted hardware.

Kai: The summary concludes with the experimental validation, noting process fidelity of eleven point four percent at fifty qubits and one point eight percent at eighty qubits, and that the correct output state stays clearly distinguishable up to one hundred qubits in this 'Experimental demonstration of the Quantum Fourier Transform on up to one hundred qubits using a convolutional compilation strategy.'

Mira: That fidelity data, coupled with the observation that for n=one hundred the mode measurement outcome consistently identifies the correct integer frequency with a signal-to-noise greater than unity in every dataset, is what makes this summary so compelling.

Lev: That high signal-to-noise ratio is critical because it means the computation isn't just succeeding by chance; it's robust enough to be considered reliable for larger problems.

The paper's improvements: Kai: Now we’re getting into the improvements they suggest, which are really about how this strategy can be used in practice, and that’s what I find most exciting.

Mira: The main improvement is the shift from the standard LNN QFT compilation to their 'Convolutional AQFT' variant.

Lev: I want to focus on the idea of reducing gate count through this specific gadget; how does that translate into a tangible benefit for running algorithms on hardware?

Kai: They suggest this strategy allows them to achieve an exact CX parity with the standard all-to-all implementation while strictly operating on an LNN architecture.

Mira: This means they’ve found a way to match the required two-qubit gate scaling of direct all-to-all architectures even when using low-connectivity hardware.

Lev: That's a huge piece of the puzzle; it means we can use hardware that isn't perfectly interconnected for tasks that previously demanded high connectivity, just with this specific compilation trick.

Kai: They also detail circuit manipulations to further reduce complexity, showing how moving certain gates allows two CX gates previously separated by an H gate to become adjacent and removable.

Mira: That structural simplification directly reduces the linear complexity term of the QFT while keeping the leading quadratic order term the same.

Lev: Simplifying that structure is exactly what makes a difference in terms of circuit depth and overall execution time, which is important for any physical execution on a qubit.

Kai: They also mention dynamic decoupling sequences inserted into idle delays using a 'robust crosstalk-suppressing embedding strategy.'

Mira: That shows they're thinking about the physical environment during the actual run, not just the abstract circuit design but how to actively suppress noise.

Lev: Integrating noise suppression directly into the compilation pipeline suggests a more holistic approach to making quantum algorithms viable on current hardware.

Conclusion: Kai: So we’re wrapping up our discussion on 'Experimental demonstration of the Quantum Fourier Transform on up to one hundred qubits using a convolutional compilation strategy.' We've covered the main points from the title, summary, and improvements.

Mira: Essentially, this paper shows that even with limited connectivity, you can use smart circuit design to get high-quality results for QFT on LNN hardware.

Lev: I think what this means is that we might be able to run significantly larger simulations on existing quantum machines than previously thought possible without needing immediate fault tolerance.

Kai: The experimental validation showed process fidelity above one percent for eighty qubits, which was the largest QFT demonstrated on any quantum computing hardware to date.

Mira: The ability to accurately extract frequency information up to one hundred qubits with a signal-to-noise greater than unity is a very strong indicator of practical utility for spectral analysis.

Lev: From my side, it’s reassuring to see that this approach provides a reliable path forward for scaling up computations in the NISQ era, even when dealing with hardware limitations.

Kai: So, this work on the 'Experimental demonstration of the Quantum Fourier Transform on up to one hundred qubits using a convolutional compilation strategy' is a significant piece of research for how we think about mapping complex algorithms onto real quantum hardware.

Paul Coote, Michael J. Biercuk, Yuval Baum

Q-CTRL

quant-ph

Submitted: 2026-08-05

Updated: 2026-09-28

Comments: v2: Correct typos, update figures, add author contribution statement, edits to Conclusion section

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 90/100

The gist: This paper presents and experimentally validates a novel "Convolutional QFT" compilation strategy for executing the Quantum Fourier Transform (QFT) subroutine on linear nearest neighbor (LNN) qubit

Key concepts

Convolutional QFT Compilation Strategy
This is a novel constructive method used to map the Quantum Fourier Transform onto linear nearest neighbor (LNN) qubit hardware. It involves a 'convolutional kernel circuit gadget' that helps reduce the average number of two-qubit gates in the causal history of each qubit, optimizing gate placement.
Linear Nearest Neighbor (LNN) Qubit Topologies
This refers to the physical arrangement of qubits on hardware where connections are limited to adjacent qubits. The paper focuses on executing complex algorithms like QFT despite these connectivity constraints through specialized compilation techniques.
Convolutional AQFT
This is the novel variant of QFT compilation introduced by the authors. It is a constructive method that aims to achieve exact CX parity with all-to-all implementations while strictly operating on an LNN architecture, using specific gate rearrangements.
Signal-to-Noise Ratio (SNR) > 1
This indicates that the mode measurement outcome consistently identifies the correct integer frequency with a signal strength greater than one in every dataset. This high SNR is critical because it means the computation is robust enough to be considered reliable for larger problems.

Terminology

Summary

This paper presents and experimentally validates a novel Convolutional QFT compilation strategy for executing the Quantum Fourier Transform (QFT) subroutine on linear nearest neighbor (LNN) qubit topologies, achieving demonstrations up to 100 qubits. This research is significant because it introduces a constructive compilation strategy that dramatically reduces resource overhead by matching the CX-gate scaling of direct all-to-all architectures while operating on low-connectivity hardware. The experimental results demonstrate a process fidelity above 1% for 80 qubits, representing the largest QFT demonstrated on any quantum computing hardware to date, proving the viability of this strategy for large-scale quantum algorithms in both NISQ and fault-tolerant regimes.

Compilation Strategy and Complexity Reduction

The paper introduces two primary compilation strategies: a standard LNN QFT compilation and a novel Convolutional AQFT. The initial LNN QFT derivation requires n2 − n CX gates, matching the requirements of direct compilation on an all-to-all architecture. However, the authors refine this by adding a single ancilla qubit and two additional CX gates to form the 'Convolutional QFT' or 'Convolutional AQFT.' This variant is realized via a compact, translation-invariant kernel circuit gadget that traverses a quantum register, which is motivated by reducing the average number of two-qubit gates in the causal history (or ‘light cone’ [35, 36]) of each qubit. The resulting strategy achieves an exact CX parity with the standard all-to-all implementation while operating strictly on an LNN architecture.

Derivation of the Convolutional QFT Circuit

The derivation of the Convolutional AQFT involves several circuit manipulations to achieve further reduction. Key steps include:

  1. Expressing each Hadamard gate (H) using a synthesis involving a phase gate (S).

  2. Moving the two introduced phase gates on each wire to either the front or end of the circuit, which is permitted because S has a diagonal unitary and commutes with other diagonal sub-circuits.

  3. Moving each √X gate to the left through three preceding CX gates, leveraging a circuit identity that allows a √X gate to commute through this arrangement.

This process results in two CX that were previously separated by an H gate are instead adjacent and aligned, and can be removed. The full QFT for n=5 is shown requiring 20 CX gates, which is six fewer than panel c of the Park/Ahn construction (26 CX gates). This optimization reduces the linear complexity term while maintaining the same leading quadratic order.

Experimental Validation and Performance Metrics

The strategy was validated on the IBM Quantum Platform using benchmarking circuits for widths up to 100 qubits on the Heron R3 device. The compilation pipeline involves transpilation where each CX is replaced by one CZ plus additional single-qubit gates, preserving the two-qubit gate count of the input circuit. Gate scheduling is performed as late as possible (ALAP), with a key exception for the final entangling gate on each pair to be moved forward. Dynamical decoupling sequences are inserted into idle delays using a robust crosstalk-suppressing embedding strategy.

The performance metrics show:

**: A process fidelity of 11.4% at 50 qubits and 1.8% at 80 qubits. The correct output state remains clearly distinguishable above background noise up to 100 qubits. For n=100, the mode measurement outcome consistently identifies the correct integer frequency with a signal-to-noise greater than unity in every experimental dataset. The success probability remains above the previously articulated ∼ 1% threshold up to 80 qubits. The target bitstring is observed 8.4× (7.5×) more frequently than any single incorrect output for n=50 and n=80, even after readout error mitigation, leading to an estimated unitary fidelity of 11.4% for the QFT alone at these widths. The QFT operates on a 2100-element signal-space dimension that far exceeds any classical Fourier transform implementation. The final result is the largest experimental QFT demonstrated on any quantum computing hardware to date.

Improvements for AI systems

Based on the provided scientific paper, here are specific improvements to AI systems that could be enabled by implementing or leveraging these quantum computing techniques:

The core contribution of this paper is a highly optimized compilation strategy for Quantum Fourier Transform (QFT) circuits onto hardware with limited connectivity (specifically Linear Nearest Neighbor, LNN topology), achieving near-optimal gate counts and high process fidelity.

Here are the improvements you can make and what the improved AI system can do:

  1. Improve the efficiency of Quantum Algorithms for NISQ/Fault-Tolerant Hardware:

  2. Enable More Complex Quantum Subroutines on Noisy Devices:

  3. Achieve Higher Fidelity in Large-Scale Quantum Simulations:

  1. Improve the efficiency of Quantum Algorithms for NISQ/Fault-Tolerant Hardware:

The paper introduces the Convolutional QFT compilation strategy, which reduces the required two-qubit gates from the standard Park/Ahn construction to match the all-to-all architecture baseline (i.e., achieving exactly 2n - 4 CX gates).

The improved AI system can perform:

Specifically, it can execute complex quantum algorithms like Shor's algorithm or advanced quantum simulation routines on current noisy intermediate-scale quantum (NISQ) devices or near-term fault-tolerant hardware with limited connectivity (like heavy-hex or square lattices) with significantly lower resource overhead and reduced circuit depth. This means the AI system can run deeper, more accurate computations within the constraints of current hardware limitations.

  1. Enable More Complex Quantum Subroutines on Noisy Devices:

The paper demonstrates that by employing the Convolutional QFT strategy, the causal history (light cone) of each qubit is reduced, and qubits are left idle and protected from decoherence by uninterrupted dynamical decoupling sequences.

The improved AI system can perform:

It can execute longer QFT circuits (up to 100 qubits) with a process fidelity exceeding 1% for 80 qubits, which is significantly higher than conventional implementations. This allows the AI to tackle larger problem spaces, such as simulating more complex quantum chemistry problems or analyzing larger protein folding dynamics, by maintaining high output fidelity despite hardware noise.

  1. Achieve Higher Fidelity in Large-Scale Quantum Simulations:

The paper validates the QFT's ability to correctly identify a periodic signal frequency up to 100 qubits with a process fidelity of 11.4% (at 50 qubits) and 1.8% (at 80 qubits). The convolutional strategy further reduces the average number of two-qubit gates in the causal history, which is crucial for reducing gate-level noise.

The improved AI system can perform:

It can accurately extract specific, computationally meaningful results from large quantum states—such as identifying exact frequencies within a 2100-element signal-space dimension. This capability allows the AI to serve as a high-precision spectral analyzer or frequency detector for complex quantum systems, providing accurate data that would be unattainable through classical Fourier transform implementations on such large dimensions.

Sources

Related papers