A Quantum Computer Just Did in 19 Seconds What Could Take a Supercomputer 110 Years

The quantum advantage is moving from specialized labs into the cloud.

Imagine tossing 61 coins at once — except the coins can influence one another in strange quantum ways, and before every toss you scramble them through dozens of randomly chosen operations.

Now repeat that experiment one million times and record the resulting strings of zeros and ones (heads and tails).

That, in simplified terms, is what researchers asked IBM’s Nighthawk r2 quantum processor to do. The experiment is called random-circuit sampling, and it is not meant to solve anything genuinely practical in the real world. Instead, scientists use it as a stress test: can a quantum computer produce patterns of results that would be extraordinarily difficult for an ordinary computer to reproduce?

In the new experiment, researchers applied 36 rounds of operations to 61 quantum bits, or qubits, involving 918 two-qubit interactions. The processor then generated one million results in just 19 seconds.

What makes this unique

The important part is not that a quantum computer can spit out zeros and ones quickly. Any laptop can do that. The challenge is reproducing the same probability pattern created by the quantum circuit — the subtle way some bit strings become more likely than others after the qubits interact.

Researchers led by Tigran Sedrakyan of BlueQubit, a San Francisco-based quantum computing software and cloud platform company, estimate that generating one million samples with comparable fidelity using a particular classical simulation method would require about 110 years on Frontier, one of the world’s most powerful supercomputers. IBM’s machine did the experiment in seconds.

The result, described in a preprint that has not yet been peer-reviewed, marks a new milestone in the long-running race for quantum advantage: the point at which a quantum computer can perform a specific computational task beyond the practical reach of conventional machines. And unlike many earlier demonstrations, this one used a quantum processor available to outside researchers through IBM’s cloud platform rather than a purpose-built laboratory machine.

How to Test an Answer You Cannot Calculate

The researchers at IBM needed to produce a pattern that an ordinary computer would have an extraordinarily hard time imitating. Their obvious choice was to turn to an industry standard benchmark called random-circuit sampling. They put 61 qubits through 36 rounds of operations, repeatedly forcing the qubits to interact and become entangled. With every round, the possible outcomes multiplied and the underlying probability pattern became harder for a conventional computer to keep track of.

×

Get smarter every day...

Stay ahead with ZME Science and subscribe.

Daily Newsletter
The science you need to know, every weekday.

Weekly Newsletter
A week in science, all in one place. Sends every Sunday.
No spam, ever. Unsubscribe anytime. Review our Privacy Policy.

Thank you! One more thing...

Please check your inbox and confirm your subscription.

At the end, the researchers measured the quantum processor one million times. Each measurement produced a different 61-digit string of zeros and ones.

RelatedPosts

Quantum Robots learn Faster, respond Better and Smarter
Physicists solved decades-old puzzle with huge implications for quantum computers
Quantum computer slows down virtual chemistry reaction 100 billion times
Quantum information stored in a single atom

But any computer can generate random-looking strings. The trick was whether these strings followed the very particular probability pattern created by the quantum circuit.

That presented the researchers with an awkward problem: How do you check the quantum computer’s work if calculating the full correct answer is itself too difficult?

First, they created “patched” versions of the circuit. Instead of letting all 61 qubits interact as one giant system, they deliberately cut some of the connections and split the circuit into three or four smaller groups. Those smaller pieces were simple enough for a conventional computer to simulate exactly. That gave the researchers a reference answer: they could compare what the quantum processor produced with what the classical calculation said it should produce, then use those smaller tests to estimate how much fidelity the full circuit was retaining.

The second check took a very different approach. The team built mirror circuits that made the quantum computer perform a sequence of operations and then immediately perform the exact reverse sequence. In an ideal machine, the second half should undo the first and return the qubits to their starting state. The farther the machine landed from that starting point, the more noise and error it had accumulated along the way. Crucially, this test did not require a classical computer to calculate the full quantum output.

The important part is that these two tests — one based on classically checking smaller pieces, the other on asking the quantum processor to retrace its own steps — gave closely matching results as the circuits grew deeper, giving the researchers confidence that the full experiment was behaving as expected.

At 36 cycles, the surviving quantum signal had a fidelity of about 0.23 percent. That number sounds terrible if you think of it as ordinary accuracy, but it is not an exam score. In this kind of experiment, most of the delicate quantum information is gradually washed away by noise. What matters is whether a measurable trace of the ideal quantum pattern remains — and whether a classical computer can reproduce it at comparable fidelity.

The researchers argue that 36 cycles hit a particularly important sweet spot: the circuit had become extremely expensive to simulate classically, while the quantum signal was still strong enough to detect. That is where the claimed computational advantage emerged.

“The directly supported point is the 61-qubit, 36-cycle experiment, at the knee of the contraction cost,” the authors write.

IBM’s new hardware helps explain how the researchers could collect so much data so quickly. Nighthawk r2 has 120 programmable qubits, but its biggest improvement over IBM’s previous-generation Heron processors is not simply size. It is how quickly the machine can reset itself and start again.

Quantum experiments like this one are intensely repetitive. The processor runs a circuit, measures the qubits, resets them to a clean starting state and runs it again — thousands or millions of times. On Heron, that cycle was limited partly by the time needed to make sure the qubits had settled back down. Nighthawk r2 instead uses a dedicated reset mechanism that actively drains energy from each qubit, cutting the idle time between runs to as little as one microsecond.

IBM says Nighthawk r2 can execute more than 100,000 circuits per second, compared with roughly 4,000 per second on Heron. Put another way, a batch of circuit executions that would occupy Heron for about 25 seconds could, in principle, pass through Nighthawk r2 in roughly one second. In this case, the million-sample run took just 19 seconds.

The 110-Year Figure Comes With an Asterisk

Quantum advantage has always been a moving target.

In Google’s landmark 2019 Sycamore experiment, a 53-qubit processor generated samples in about 200 seconds that researchers initially estimated would require a supercomputer roughly 10,000 years. But the claim was immediately disputed. By 2021, a team using China’s Sunway supercomputer reported an algorithm that could simulate the Sycamore sampling task in about 304 seconds on a conventional computing platform. More recent experiments, including a 67-qubit Google study published in Nature in 2024, have therefore paid closer attention to noise and to classical strategies that can imitate benchmark scores.

The new study acknowledges that its110-year figure assumes a particular tensor-network simulation and unlimited memory. Better algorithms, reuse of intermediate calculations and other approximation strategies could shrink that number substantially. The authors explicitly note that history suggests some will.

So, Nighthawk r2 has not suddenly made classical supercomputers obsolete, nor has it solved a commercially useful problem.

But it has moved an important boundary. A quantum experiment that appears extraordinarily expensive to reproduce classically can now be run in seconds on hardware that researchers can access through the cloud — and, crucially, challenge for themselves.

The findings were described in the pre-print server arXiv.