Photon-stimulated decay of $χ$-matched ancillas causes unheralded bit flips in bosonic codes

In the quest to build a quantum computer that can solve problems beyond the reach of classical machines, scientists face a relentless enemy: noise. Quantum information is incredibly fragile, easily scrambled by the slightest vibration or fluctuation in its environment. To protect this delicate data, researchers have developed a strategy called error correction. Instead of trying to make the physical components perfect, they spread a single piece of information, known as a logical qubit, across many physical components. If one part fails, the system can detect the error and fix it without destroying the information. One promising approach uses light trapped inside a microwave cavity, storing data in the number of photons, or particles of light, bouncing around inside. To check if the data is still safe, the system needs a helper, a small quantum device called an ancilla, which acts like a sensor to read the state of the light without touching it directly.

For years, engineers have relied on a specific type of helper, a superconducting circuit known as a transmon, which has been tuned so that its energy levels match the light in a very precise way. This matching was believed to be a perfect shield. The theory held that if the helper made a mistake and dropped to a lower energy state, the system would know immediately and could correct it, or that certain dangerous mistakes were physically impossible due to the rules of symmetry governing the system. This design has been used in real quantum processors, such as the Ocelot repetition code developed by researchers at AWS, where it successfully stored information for milliseconds. The prevailing assumption was that the helper's errors were independent of how much light was stored; the more light there was, the better the protection, and the helper's behavior remained constant.

However, a new analysis by Aleksandr Gulkanov at Rice University suggests that this shield has a hidden crack. By looking closely at how the helper interacts with the light inside the cavity, the researcher found that the very photons meant to protect the data can actually trigger a specific type of failure in the helper. The study shows that when the cavity is filled with photons, the helper can undergo a transition that was previously thought to be forbidden. In this process, the helper drops to a lower energy state while simultaneously adding a photon to the light field. Crucially, this event happens without any warning signal to the computer. The system does not know an error has occurred, and because the helper's state changes in a way that confuses the data, it flips the stored information. This is a silent error, one that the computer cannot detect or fix.

The researchers did not just propose this idea theoretically; they built a detailed model of the actual Ocelot device to see how this hidden channel would behave in a real machine. They found that the rate of these silent errors depends directly on the number of photons in the cavity. As the amount of stored light increases, the probability of this specific failure grows. This is a significant departure from previous models, which assumed the error rate would stay flat regardless of the light intensity. In their simulations, the team observed that for the Ocelot device, the chance of a bit flip caused by this mechanism increases linearly as the number of photons rises from four to ten. This growth means that simply adding more light to make the code stronger eventually hits a wall. Instead of the error rate continuing to drop exponentially as hoped, it begins to climb, creating a floor below which the system cannot go.

This discovery challenges the current understanding of how to optimize these quantum codes. The study indicates that there is an optimal size for the light storage, a specific number of photons where the error rate is lowest. Going beyond this point, by trying to store more light to gain more protection, actually makes the system more vulnerable to this specific type of noise. The researchers calculated that for the devices currently in use, this limit might cap the system's ability to distinguish between different types of errors, effectively capping the performance of the computer. They also noted that while the effect is small in current experiments, which have only tested up to four photons, the trend is clear in their model. If the technology scales up to store more light, this silent failure mode will become the dominant source of errors, overtaking other known problems.

The paper also explores why this happens. It turns out that the helper and the light are not just sitting next to each other; they are deeply intertwined. The presence of the light changes the helper's energy landscape, allowing a path for decay that is blocked when the light is absent. This path is driven by electrical noise, a common background hum in these circuits. When the light is present, it acts as a catalyst, stimulating the helper to make a jump that it would not make on its own. The researchers showed that this effect is unavoidable for the specific type of helper currently used, regardless of how strong the connection between the helper and the light is. The only ways to reduce this risk are to change the design of the helper, use a different type of circuit entirely, or accept that there is a limit to how much light can be used for protection.

The findings have immediate implications for the design of future quantum computers. Engineers who have been planning to increase the size of these light-based codes to improve their performance may need to reconsider their strategies. The study suggests that pushing for larger codes without addressing this specific interaction could lead to diminishing returns or even worse performance. The researchers emphasize that their work is a simulation based on the known physics of the Ocelot device, calibrated against static measurements of the hardware. While the actual growth of errors has not yet been observed in experiments because the current devices have not been tested with enough light to see the trend, the theoretical framework is robust. The model predicts that if the experiments were extended to higher photon numbers, the error rate would rise, confirming the existence of this new channel.

Ultimately, this work serves as a reminder that in quantum systems, the tools used to protect information can sometimes become the source of its destruction. The photons that stabilize the code also open a door for noise to slip in. By identifying this mechanism, the study provides a clear target for future improvements. It tells researchers that to build better quantum computers, they must look beyond the simple idea of "more light is better" and instead focus on the intricate dance between the helper and the data it is meant to protect. The path forward involves either redesigning the helper to avoid this interaction or finding new ways to manage the noise that drives it, ensuring that the next generation of quantum machines can truly harness the power of light without falling victim to its own presence.