There are many algorithms for which it has been mathematically proven that a quantum computer can generate results that would take a classical computer an unreasonable amount of time to generate. Unfortunately, today’s quantum computers either can’t run those algorithms or can only run simplified versions that classical computers can also handle. This has left the field facing a challenging question: Can we demonstrate the promise of quantum computers on today’s noisy, limited hardware?

That’s a more difficult question than it may first appear. If you generate a result that’s out of reach of today’s regular computers, it may not be possible to verify that you got the right result. And given that today’s quantum computers are somewhat error-prone, getting the wrong result is a distinct possibility. Further, in the absence of a mathematical proof of the capabilities of quantum hardware, it’s possible that a better classical algorithm could outperform the quantum hardware.

These issues inspired IBM to launch a quantum advantage tracker. On Thursday, the company announced three new entries that it says clearly show a quantum advantage, each using a different approach to overcoming errors and validating quantum results. “Trusted computing when you can do classical simulations is irrelevant,” IBM’s Jay Gambetta told Ars. “Trusted computing when you can’t do classical simulations is a big deal.”

None of the results are immediately useful, but they hint that we might be heading in the right direction.

Trust, but verify

At this point, there have been many claims of quantum advantage, and at least one has the potential to be useful. But in a number of high-profile cases, algorithm developers have developed optimized algorithms that have severely reduced the advantage, bringing classical computers back up to par. Another issue is verification. If your quantum computer is generating a statistical pattern by re-running variations on a single set of operations, a systemic error could potentially bias the output, and you couldn’t use a classical computer to check.

These issues are typically handled by performing simplified calculations using fewer qubits and verifying the results on classical hardware. If that works, it’s assumed that the algorithm will continue to work when it is run with more qubits. But that’s not the only option. Some algorithms could produce results that are difficult to calculate but easy to verify—for example, factoring the product of multiplying two large primes.

Unfortunately, if anyone has identified a calculation that could be run on today’s hardware, I’m not aware of it. S0 computer scientists have had to get creative. And really, that’s what today’s announcement is about: three creative ways of handling the fact that today’s processors are error-prone.

One of the new efforts was a collaboration among IBM, RIKEN in Japan, and a small company called Qedma, which develops software that helps mitigate errors in current quantum processors. The work focuses on modeling a Floquet process, in which a system oscillates while subject to an external force that gradually alters its behavior. Think of a pendulum that gradually slows down due to friction.

These sorts of processes can also occur in quantum systems, and the Qedma team modeled something called an Ising model, which you can think of as a hypothetical two-dimensional grid of magnets, where the orientation of each can affect its neighbors. After setup, the orientations will gradually undergo periodic flips as they try to find a low-energy configuration in which neighboring magnets have opposite orientations. The complexity of modeling the intervening states of the system during these flips increases as you add more magnets.

So Qedma chose to model something that wasn’t too large to fit into existing quantum hardware, then worked with RIKEN to run two different classical algorithms on the Fugaku supercomputer, which was the world’s most powerful computer five years ago. The classical algorithms clearly showed that something was wrong, as they produced answers that diverged over time (one showing net magnetism decreasing smoothly, the other showing it increasing).

When run on an IBM quantum processor with Qedma’s error-mitigation software, the algorithm showed something else entirely: a gradual decrease in magnetism, with periodic oscillations. One classical algorithm got the oscillations but showed magnetism increasing, while the other showed it decreasing much faster without the oscillations.

To demonstrate that this wasn’t the product of some consistent error in the IBM hardware, the team turned to a Quantinuum processor and confirmed its output. They also identified a problem in at least one of the quantum algorithms: to boost performance, it truncates some terms needed to produce the oscillatory behavior.

Exponentially hard

Another new manuscript comes from a collaboration between IBM and researchers at the University of Chicago. It’s similar in principle to one of the algorithms mentioned above: It repeats variations on an algorithm multiple times to get a sample of results that give a sense of the statistics of different outputs. Because the algorithm is run on a quantum computer, different outcomes can interfere with each other, making it challenging to simulate on classical hardware. It’s possible to run it a few times on classical machines, but not enough to get decent statistics on the output.

In this case, the team made a couple of key variations. The first is that it mostly performed what are called Clifford gates, which are relatively easy to simulate on classical hardware. But it sprinkled in a few non-Clifford gates (specifically T gates) of a specific type chosen in part because they are less prone to error. “Z rotations (including T gates) are special in our hardware: they are implemented by virtual frame tracking and do not add extra noise,” the paper said.

But the T gates also help ensure that this is especially hard to simulate on a classical computer. “It’s got a stronger complexity argument because of the [T gates], which you can prove on average is exponentially hard to sample for a classical computer,” Gambetta told Ars. That will make it very challenging for classical algorithms to catch up.

The work also linked in a few additional qubits around the periphery of those used for the algorithm, arranged so that gentle measurements performed during the operations could detect whether errors had occurred; if they were detected, the results were discarded. (Note that this would also throw out valid results that were flagged by an erroneous read of these additional qubits.)

The result was an algorithm that “combines the broad output statistics of hard sampling problems with circuit structure that can be exploited for error detection and fidelity certification,” the team said.

The last of the new results comes from quantum software developer Algorithmiq, which used an algorithm similar to the one in Google’s “quantum echoes” work. A set of gates first alters a quantum system, after which the process is reversed. Additional operations performed during the reversal prevent the system from returning to its original state—instead, the noise creates an imperfect “echo” of the forward process. As with one of the earlier works, attempts to simulate this on classical hardware require some simplification, and different simplification methods yield different results. By its nature, then, the problem is beyond the reach of classical hardware.

The people behind the manuscript set to work removing all the noise from the system. They started by choosing a specific area of the quantum processor with the lowest noise and used neighboring qubits to determine whether any were inappropriately altered during the computation, indicating that something was going wrong. They also optimized the control signals sent to the qubits, along with other techniques that should suppress noise.

They then intentionally injected noise, determined how it altered their results, and provided an estimate of the amount of noise present without it. They also repeated the entire process on a separate IBM processor, which should exhibit a different noise pattern. All of this allowed them to set an error rate on their calculation—there may be some noise left, but they know it must be below a value they can calculate.

Next steps

There are many ways you could view this work. Cynically, it’s definitely the case that none of these algorithms are useful in any real sense. Even those that model the behavior of quantum systems use incredibly simplified models that don’t reflect any real-world systems. It’s also worth noting that some past claims of quantum advantage haven’t held up, as researchers have improved on classical algorithms, something that may yet happen here.

Finally, these sorts of algorithms—performing computations directly on hardware qubits with problematic noise rates—will fade in a few years as we start to get reasonable numbers of error-corrected qubits. In fact, a number of companies have indicated that they’re holding off on offering any publicly accessible hardware until we get there.