Resolving and Suppressing Temporally Correlated Noise in Quantum Error Correction
Using a 105-qubit superconducting processor, this study demonstrates the successful scaling of surface code stability to suppress temporally correlated errors caused by qubit heating, achieving a record-low logical error floor via a walking stability circuit and optimizing performance through adaptive syndrome extraction.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the author. For technical accuracy, refer to the original paper. Read full disclaimer
To build a computer that can solve problems beyond the reach of today's machines, scientists are trying to create a quantum computer. These devices use the strange rules of quantum physics to process information, but they are incredibly fragile. The slightest disturbance from heat, vibration, or radiation can cause the information to scramble and disappear. To make these machines useful, researchers must build a system that can automatically find and fix these mistakes as they happen, a process known as quantum error correction.
The standard way to test if this system works is to create a "memory" experiment. In this test, scientists store a piece of information and repeatedly check it for errors, hoping to see if the computer can keep the data safe for a long time. However, this approach only checks one type of mistake: errors that happen across many parts of the machine at the same moment. Real-world quantum computers will need to do more than just remember; they will need to perform complex calculations. These calculations are sensitive to a different kind of trouble: errors that happen in the same spot over and over again as time passes. If a computer cannot handle mistakes that linger in time, it will fail at the very tasks it was built to solve.
A team of researchers at Google Quantum AI and their collaborators set out to understand and fix this specific problem. They used a new, large-scale quantum processor called Willow, which contains 105 superconducting qubits, the basic units of quantum information. Instead of just testing memory, they ran a "stability" experiment. This test is designed to be sensitive to errors that persist over time, acting as a mirror image to the standard memory test. By scaling this experiment from small grids of qubits to a large 7-by-7 grid, they were able to see how well the system could suppress these time-based errors as the machine grew larger.
The researchers found that as they increased the size of the grid, the system did indeed get better at suppressing errors, but only up to a point. Initially, the error rate dropped rapidly as expected. However, after about ten cycles of checking, the improvement hit a wall. The error rate stopped falling and began to level off, a phenomenon the team identified as a "knee" in the data. By building a detailed model of the machine's behavior, they discovered the culprit: a specific type of quantum state that the data qubits were accidentally heating up into.
In the quantum world, a qubit usually exists in one of two states, like a coin that is either heads or tails. However, these physical qubits can also slip into higher energy states, similar to a coin spinning on its edge or even flipping into a third, hidden state. The researchers found that their data qubits were occasionally heating up into a third excited state, which they call the |3⟩ state. Once a qubit gets stuck in this state, it corrupts the measurements of its neighbors for many cycles in a row, creating a chain of errors that the standard correction system cannot easily fix. The team's model, which included the physics of how these higher states move and decay, perfectly matched the experimental data without needing any adjustable parameters, confirming that this heating was the primary cause of the error floor.
To solve this, the team developed a new method called a "walking" stability circuit. In a standard circuit, the roles of the qubits remain fixed: some hold the data, while others act as sensors to check for errors. In the walking circuit, the roles swap back and forth. The data qubits become sensors, and the sensors become data, and this happens every few cycles. Crucially, when a qubit acts as a sensor, it is reset in a way that clears out not just the normal errors, but also these higher, unwanted energy states. By periodically shuffling the qubits and resetting them, the team was able to flush out the stuck particles before they could cause a cascade of mistakes.
The results of this new approach were dramatic. While the standard circuit hit a wall where errors stopped improving, the walking circuit continued to suppress errors, reaching a logical error probability of less than 3.20 × 10⁻⁸ after 60 cycles. This is two orders of magnitude better than the standard method at the same point. The only thing that stopped the walking circuit from getting even better was a rare, random burst of ionizing radiation from the environment, which is a fundamental limit of the hardware rather than a flaw in the design.
The researchers also explored a way to make the process more efficient by using the computer's own "confidence" to decide when to stop. In a typical experiment, the machine runs for a fixed number of cycles. However, the team found that by analyzing the data in real time, they could tell when the system was confident enough that no errors remained. If the system was clean, they could stop early; if it was confused by a burst of noise, they could wait longer. This adaptive strategy reduced the total time the experiment needed to run by 34% and lowered the overall error rate by 38%.
This work demonstrates that simply testing a quantum computer's memory is not enough to guarantee it will work for complex calculations. The team showed that time-correlated errors, caused by qubits getting stuck in higher energy states, are a major hurdle that must be addressed. By identifying the specific physical cause of these errors and inventing a circuit that actively removes them, they have taken a significant step toward building a machine that can run long, reliable quantum algorithms. The study confirms that with the right tools, these stubborn, time-based errors can be tamed, paving the way for larger and more powerful quantum processors.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.