Quantum error correction can constantly recalibrate a processor - Ars Technica

Overview

Quantum error correction can constantly recalibrate a processor

Reinforcement learning uses error information to adjust control algorithms.

Details

There are some obvious big picture issues that stand between us and useful quantum computing. Issues like whether we can make enough high-quality hardware qubits to connect into the error-corrected logical qubits we need, and how we generate the states needed to perform universal computation on those logical qubits. But there are also many less prominent challenges that will need to be solved before we can perform calculations.

One of those challenges, which only affects some types of hardware, is calibration. For devices we manufacture, like superconducting qubits, there are always subtle variations among individual qubits. (This is not true when we use something like an atom to hold the qubit, but the lasers that control them can drift.) As a result, this hardware is put through a process called calibration, where we test different frequencies and amplitudes of the microwave pulses that control them to find the combination that produces the lowest error rates, and then save those settings for use in calculations.

However, you can’t perform the typical calibration process while e you’re doing calculations, which means drift becomes an issue for long and complicated algorithms. Google, though, has figured out that it’s possible to do calibration using the same data that’s used for error correction.

The hardware that Google and a number of other companies rely on are transmons. They consist of a loop of superconducting wire connected to a resonator, and they’re controlled by pulses of microwave photons. Those pulses are controlled by hardware that is kept outside of the refrigeration, including classical computers and the microwave sources they control. This hardware is used to test different combinations of wavelengths and amplitudes during calibration.

This equipment can also drift from its initial settings due to random factors, such as the hardware heating up as it’s used. And that could be an issue for the sorts of complicated algorithms we ultimately intend to run on quantum computers, like those that could crack current encryption. Currently, if the system shows signs of drifting away from calibration, Google says that it simply stops the computations and recalibrates. However, that is not going to be an option partway through a complicated calculation.

These computations will be taking place using error-corrected qubits, in which measurements on a subset of the hardware qubits are used to detect and characterize any errors that occur on the ones that hold the data. As the Google researchers point out in their paper, some of the errors they’ll detect will be the product of calibration failures: “errors from imperfect calibrations produce detectable syndromes just like all other errors.” In theory, we could use the same error detection to identify both random errors and those produced by calibration issues.

The challenge is telling the two apart. The team’s solution? Reinforcement learning, in which the computer tries different configurations of the 1,000 or so control parameters it has access to, and scores their effectiveness at limiting errors. “We deliberately apply small, simultaneous perturbations to all control parameters during the computation to explore the control space,” the team wrote. “These perturbations translate into subtle changes in the statistics of error-detection events.”

Using that information, the system can infer how adjusting these parameters can minimize certain errors. If those errors start to show up, it can make the appropriate adjustments. And that can be done in parallel with the error detection and correction system that manages the logical qubit.

The system was put in charge of two logical qubits hosted on a calibrated system. The two were using different error correction schemes (a surface code and a color code). These were set in a specific state, and the error-correction system was then used with and without reinforcement-learning-driven corrections. Having the system active led to a 20 percent increase in the ability to detect and correct errors in the logical qubits.

The limitation of this approach is that it works only if the drift keeps the system reasonably close to the state the system was trained in. The corrections that might bring things back into alignment from one state might not be effective when the system’s in a significantly different state.

The solution to this is to constantly re-evaluate the effectiveness of different changes. But this has an obvious problem: You can’t simply randomize all the potential control configurations in the middle of a calculation. Even with limited variation, the system will necessarily operate outside its optimal error correction. So, the question was whether the frequent sub-optimal error correction paid off by keeping drift from causing even larger problems. “The favourable resolution of the exploration–exploitation trade-off would mean that the aggregate performance of all sampled policy candidates, most of which are worse than [the optimal one], is still better than the performance without reinforcement learning steering,” the researchers write.

Performing many simulations with a very small error-corrected qubit showed that the trade-off worked out, provided that drift was slow enough. The team showed that it could work in real time with a large error-corrected qubit, in which the reinforcement learning system had control over roughly 40,000 parameters.

This is clearly not a solution for the present; we can only keep systems operating for long enough to perform relatively short, simple algorithms, so drift isn’t even a concern. Ultimately, our intention is to build hardware that can perform the sorts of calculations where issues like this will matter. And there’s some value in demonstrating that something we know could be a problem can be dealt with.

Nature, 2026. DOI: 10.1038/s 41586-026-10759-2 (About DOIs).

1.          Suspecting AI cheating, Ivy League prof ordered an in-person final; scores fell 50%
   

2.          US seeks cheaper hunter-killer drones after Iran destroys $1B worth of Reapers
   

3.          Allstate accuses Broadcom of auditing it because it quit VMware, CA
   

4.          Judge doesn't like Elon Musk settlement with SEC, but says court can't block it
   

5.          Like a cheat code for your car: We investigate ECU tuning
   

Ars Technica has been separating the signal from the noise for over 25 years. With our unique combination of technical savvy and wide-ranging interest in the technological arts and sciences, Ars is the trusted source in a sea of information. After all, you don’t need to know everything, only what’s important.

Key Takeaways

• Quantum error correction can constantly recalibrate a processor

• Reinforcement learning uses error information to adjust control algorithms

• There are some obvious big picture issues that stand between us and useful quantum computing

• One of those challenges, which only affects some types of hardware, is calibration

• However, you can’t perform the typical calibration process while e you’re doing calculations, which means drift becomes an issue for long and complicated algorithms