The Quantum Fourier Transform (QFT) is one of the most fundamental building blocks of quantum algorithms. Now, it’s reached a new milestone driven by advances in algorithm design and executed on IBM quantum hardware.

Recent work by researchers at quantum startup ParityQC demonstrates a QFT executed across 52 qubits on an IBM Quantum Heron r3 processor—the largest such demonstration to date. The results set a new benchmark in size and performance for QFT circuits, which are notoriously challenging to implement at scale on today’s quantum computers. But the real significance of this achievement goes beyond the headline numbers.

“It’s not about the qubit count,” said ParityQC co-founder and co-CEO Wolfgang Lechner, who noted that the new work nearly doubles a previous QFT benchmark set in 2024 on trapped-ion hardware. “With our method, we were actually able to reduce the errors and still get this doubling.”

That accomplishment could represent a key step toward practical quantum applications.

Build your own quantum Fourier transform on IBM Quantum Platform. Explore our QFT course module and run circuits today.

What is a QFT?

The quantum Fourier transform is a quantum analogue of the classical Fourier transform, a mathematical operation that decomposes complex signals—such as waves in the time domain—into their underlying frequency components. It’s similar to how your brain picks out a single voice in a busy room. The sound reaching your ear is a complex mix, but with the right processing, you can break it down into individual components.

A QFT performs a similar kind of decomposition on quantum information. It acts on the amplitudes of a quantum state, reorganizing them into a new representation that reveals hidden structures in the data. This transformation allows Shor’s algorithm to efficiently find repeating patterns in large numbers, and enables quantum phase estimation to extract key properties of quantum systems.

“Even if you think about addition—adding two numbers—if you do this on a quantum computer, it's based on QFT,” Lechner said.

This versatility helps make the QFT an essential benchmark for measuring quantum hardware performance. “It's an important benchmark because it is a building block for many other algorithms,” Lechner said, “and I would go so far to say that it should be a standard component of a quantum device.”

What makes the QFT so challenging?

A QFT requires precision across long circuits, coherent control over many qubits, and high connectivity between even distant qubits in the same system. That last point poses a real challenge for superconducting quantum processors, whose qubits mostly interact with their nearest neighbors.

Traditionally, superconducting quantum processors address this limitation with SWAP operations, which move quantum states across the device so distant qubits can interact. But this comes at a cost.

Each SWAP adds additional gates, increasing circuit depth and amplifying accumulated error. Over many operations, this routing overhead can dominate the computation. That separation between computation and routing is a major bottleneck.

If you’ve experimented with QFT circuits yourself, you’ve likely seen this effect firsthand. As system size grows, transpilation introduces more routing overhead, increasing circuit depth and reducing fidelity. The ParityQC team developed a method to overcome this challenge.

“Previously, it was like you do the swapping, which is the logistics, and the algorithm,” Lechner said. “In our case, we are able to merge these two things.”

Eliminating SWAPs by rethinking representation

ParityQC’s method, called Parity Twine, rethinks this problem from the ground up. Instead of tracking the state of individual qubits, it tracks parity information—the relationships between qubits.

Rather than using SWAP gates to transfer quantum states from one qubit to the next, parity information is transferred along physical qubits using sequences of CNOT gates, reducing gate count and circuit depth.

You can see this illustrated in the figure below:

This circuit diagram shows a QFT implemented using chains of operations across a lattice of qubits. Each color corresponds to information that, in a traditional circuit, would remain associated with a single qubit.

“In a standard algorithm, you would just have a yellow qubit that goes across the chip [via SWAP gates] and is somewhat localized,” Lechner said. “In the parity method, the green and the yellow sort of share one qubit and the colors start to mix.”

In conventional circuits, quantum states move between qubits but remain localized. In the parity architecture, that information becomes delocalized, flowing through overlapping pathways that both perform computations and propagate correlations—gradually distributing and recombining across the system.

“This is a fundamental difference, and it changes a lot of things,” Lechner said. “For example, [traditionally], if you have two qubits and you want to do an operation, you also have to do an operation between two qubits. In our picture, because we have this relative information, an interaction between [two qubits] becomes a single-qubit operation.”

That conceptual shift applies to how the computation is represented at a higher level, rather than to the underlying hardware operations, but it makes a real impact. It means that multi-qubit interactions—typically among the most resource-intensive operations in quantum computing—can, at least in some cases, be reduced to simpler primitives.

How the quantum ecosystem helps technology scale

Using this approach, the ParityQC team demonstrated a record-setting QFT, achieving both large scale and high fidelity in the computation. The researchers say the IBM Quantum Heron r3 played an important role in enabling these results. “Our experiments show that this is the best hardware around at the moment,” Lechner said.

A key metric in the work is process fidelity, which measures how accurately a full algorithm (i.e. the full QFT) was implemented. There are many different ways to measure process fidelity for quantum circuit executions, but in general, the aim is to capture the combined effects of circuit depth, noise accumulation, and compilation strategy—enabling comparisons across hardware platforms.

“We want to compare all these different quantum devices,” Lechner said. “Are they built on superconducting qubits, ions, or atoms? This shouldn’t matter. We want to compare them, and the process fidelity is [one way to do that].”

To benchmark the Parity Twine method, the team compared it to highly optimized, state-of-the-art circuits produced using the Qiskit transpiler. They found that Parity Twine delivered improved process fidelity, particularly as system size increased, as illustrated in the figure below.

These results reflect how progress happens in a healthy quantum ecosystem. Platform tools like Qiskit and the Qiskit transpiler provide a strong foundation, while innovators across academia, startups, and industry work to develop new approaches that may improve performance.

From benchmarks to broader workloads

The insights gained from the ParityQC team’s recent achievement extend far beyond any one algorithm. Many interesting problems—especially those involving all-to-all interactions—face similar challenges related to routing, depth, and noise.

As hardware continues to advance, new approaches that rethink how quantum information is represented and manipulated could enable exploration of larger problem instances and more efficient implementations for quantum optimization and simulation workloads.

Results like this don’t yet translate directly into an application-level advantage, but they give us a glimpse at what scalable performance might soon look like. Eventually, the ParityQC team plans to release a function that will allow developers to explore the Parity Twine method for themselves.

You can experiment with QFT circuits and different circuit optimization methods for yourself on IBM Quantum Platform. Explore our QFT course module and tutorials on circuit transpilation to see firsthand how circuit structure, connectivity, and compilation choices shape performance on real quantum hardware.