Search will be available as the English edition grows.
Google has demonstrated a new way to produce a critical resource for error-corrected quantum computers. On its Willow processor, the method reduced errors by about 40 times and achieved a reported fidelity of 99.99 percent.
Quantum computers are highly sensitive to noise and errors. To perform long and complex calculations, information therefore has to be protected through quantum error correction, where multiple physical qubits represent more robust logical qubits.
But error correction alone does not solve everything.
Building a universal, error-corrected quantum computer also requires certain operations that can be carried out using special quantum states known as magic states. These act as a consumable resource: a state is used to perform a required operation and then has to be replaced.
Producing magic states with very low error rates can be extremely resource-intensive. Google points to earlier estimates in which as much as 95 percent of the capacity in some future quantum architectures could be devoted to producing them.
In the worst case, that means a large share of the machine would be used to make resources needed for the computation rather than performing the computation directly.
The method Google has now demonstrated is called magic state cultivation.
The principle was developed theoretically by Google researchers in 2024. Instead of producing a very pure magic state from the outset, the system starts with a more error-prone state and performs a series of carefully coordinated measurements while the state is protected by quantum error correction.
The measurements are used to look for signs of errors.
If the system detects problems, the attempt is discarded. States that pass the checks can be retained at substantially higher quality.
The researchers have now made this process work on physical quantum hardware.
In the experiment, the researchers used Google's superconducting Willow processor.
Magic state cultivation reduced errors by roughly a factor of 40 compared with the relevant state without cultivation. The researchers report a fidelity of 0.9999(1), or about 99.99 percent, for T-states produced with the method.
There is an important limitation, however: only about 8 percent of the attempts were retained after filtering.
The 40-fold figure therefore does not mean Google can now produce magic states 40 times more cheaply or use 40 times fewer qubits. It describes the reduction in errors among the relevant produced states.
How much resource saving this ultimately provides in a large quantum computer still has to be demonstrated.
The researchers also demonstrated something that could matter for integrating the method into larger quantum architectures.
The purified state was first produced using a so-called color code, which is well suited to cultivation. The researchers then transferred it to a surface code, one of the most established approaches to quantum error correction.
The experiment moved from a distance-3 color code to a distance-5 surface code.
This matters because an efficient way to produce magic states has limited value if the result cannot be moved into the error-correction system used by the rest of the quantum computer.
Magic state cultivation has looked promising on paper, but a real quantum processor is far less tidy than a theoretical model.
The researchers encountered problems including slow variations in the electronics and temperature changes in the laboratory. These affected the measurements enough that the team had to develop additional controls and a new method for evaluating the results.
That makes the demonstration interesting beyond the 40-fold figure itself.
A method that previously existed mainly as theory and simulation has now been demonstrated under the imperfect conditions of physical superconducting quantum hardware.
The result does not mean Google has solved quantum error correction or that a large practical quantum computer is just around the corner.
Cultivation still has to be demonstrated with larger error-correcting codes and in systems that can produce and consume magic states continuously. Future machines must also handle many other problems, from logical gates and decoding to scaling control systems and large numbers of physical qubits.
Google itself emphasizes that the method still needs to be demonstrated at larger scale.
But if magic state cultivation continues to work as systems grow, it could reduce the amount of hardware that has to be reserved for one of the most expensive parts of error-corrected quantum computing.
That is why the result matters: Google has not built the practical quantum computer yet, but one of the ingredients it may need has become substantially more manageable.
KEEP EXPLORING
Quantinuum reports 99.9995% logical memory fidelity on its Helios system. The result shows strong error suppression with a color code, while scaling to useful fault-tolerant computation remains unproven.
Measurements in an electron-doped copper oxide directly link superconductivity to antiferromagnetic spin fluctuations. The result resolves an important part of the puzzle, but not the mechanism behind the highest transition temperatures.
E(3)-Pose learns the physical symmetries of the fetal brain and estimates head position from rapid 3D MRI. The goal is to let future scanners adjust diagnostic images as the fetus moves.