{"id":356,"date":"2023-02-22T17:39:48","date_gmt":"2023-02-22T17:39:48","guid":{"rendered":"https:\/\/todaysainews.com\/index.php\/2023\/02\/22\/suppressing-quantum-errors-by-scaling-a-surface-code-logical-qubit-google-ai-blog\/"},"modified":"2025-04-27T07:34:18","modified_gmt":"2025-04-27T07:34:18","slug":"suppressing-quantum-errors-by-scaling-a-surface-code-logical-qubit-google-ai-blog","status":"publish","type":"post","link":"https:\/\/todaysainews.com\/index.php\/2023\/02\/22\/suppressing-quantum-errors-by-scaling-a-surface-code-logical-qubit-google-ai-blog\/","title":{"rendered":"Suppressing quantum errors by scaling a surface code logical qubit \u2013 Google AI Blog"},"content":{"rendered":"

[ad_1]
\n<\/p>\n

\nPosted by Hartmut Neven, VP of Engineering, and Julian Kelly, Director of Quantum Hardware, on behalf of the Google Quantum AI Team<\/span><\/p>\n

<\/p>\n

\nMany years from today, scientists will be able to use fault-tolerant quantum computers for large-scale computations with applications across science and industry. These quantum computers will be much bigger than today, consisting of millions of coherent quantum bits, or qubits. But there\u2019s a catch \u2014 these basic building blocks must be good enough or the systems will be overrun with errors.\n<\/p>\n

<\/p>\n

\nCurrently, the error rates of the qubits on our 3rd generation Sycamore<\/a> processor are typically between 1 in 10,000 to 1 in 100. Through our work<\/a> and that of others, we understand that developing large-scale quantum computers will require far lower error rates. We will need rates in the range of 1 in 109<\/sup> to 1 in 106<\/sup> to run quantum circuits that can solve industrially relevant problems.\n<\/p>\n

\nSo how do we get there, knowing that squeezing three to six orders of magnitude of better performance from our current physical qubits is unlikely? Our team has created a roadmap that has directed our research for the last several years, improving the performance of our quantum computers in gradual steps toward a fault-tolerant quantum computer.\n<\/p>\n\n\n\n\n
<\/a><\/td>\n<\/tr>\n
Roadmap for building a useful error-corrected quantum computer with key milestones. We are currently building one logical qubit that we will scale in the future.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

\nToday, in \u201cSuppressing Quantum Errors by Scaling a Surface Code Logical Qubit<\/a>\u201d, published in Nature<\/em>, we are announcing that we have reached the second milestone on our roadmap. Our experimental results demonstrate a prototype of the basic unit of an error-corrected quantum computer known as a logical qubit<\/em>, with performance nearing the regime that enables scalable fault-tolerant quantum computing.\n<\/p>\n

From physical qubits to logical qubits<\/h2>\n

\nQuantum error correction<\/a> (QEC) represents a significant shift from today\u2019s quantum computing, where each physical qubit on the processor acts as a unit of computation. It provides the recipe to reach low errors by trading many good<\/em> qubits for an excellent<\/em> one: information is encoded across several physical qubits to construct a single logical qubit<\/a><\/em> that is more resilient and capable of running large-scale quantum algorithms. Under the right conditions, the more physical qubits used to build a logical qubit, the better that logical qubit becomes.\n<\/p>\n

\nHowever, this will not work if the added errors from each additional physical qubit outweigh the benefits of QEC. Until now, the high physical error rates have always won out.\n<\/p>\n

\nTo that end, we use a particular error-correcting code called a surface code<\/em> and show for the first time that increasing the size of the code decreases the error rate of the logical qubit. A first-ever for any quantum computing platform, this was achieved by painstakingly mitigating many error sources as we scaled from 17 to 49 physical qubits. This work is evidence that with enough care, we can produce the logical qubits necessary for a large-scale error-corrected quantum computer.\n<\/p>\n

Quantum error correction with surface codes<\/h2>\n

\nHow does an error-correcting code protect information? Take a simple example from classical communication: Bob wants to send Alice a single bit that reads \u201c1\u201d across a noisy communication channel. Recognizing that the message is lost if the bit flips to \u201c0\u201d, Bob instead sends three bits: \u201c111\u201d. If one erroneously flips, Alice could take a majority vote (a simple error-correcting code) of all the received bits and still understand the intended message. Repeating the information more than three times \u2014 increasing the \u201csize\u201d of the code \u2014 would enable the code to tolerate more individual errors.\n<\/p>\n\n\n\n\n
<\/a><\/td>\n<\/tr>\n
Many physical qubits on a quantum processor acting as one logical qubit in an error-correcting code called a surface code.<\/em><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

\nA surface code takes this principle and imagines a practical quantum implementation. It has to satisfy two additional constraints. First, the surface code must be able to correct not just bit flips, taking a qubit from |<\/text>0\u27e9<\/text> to |<\/text>1\u27e9<\/text>, but also phase<\/a> flips. This error is unique to quantum states and transforms a qubit in a superposition<\/a> state, for example from \u201c|<\/text>0\u27e9<\/text> + |<\/text>1\u27e9<\/text>\u201d to \u201c|<\/text>0\u27e9<\/text> – |<\/text>1\u27e9<\/text>\u201d. Second, checking the qubits\u2019 states would destroy their superpositions, so one needs a way of detecting errors without measuring the states directly.\n<\/p>\n

\nTo address these constraints, we arrange two types of qubits on a checkerboard. \u201cData\u201d qubits on the vertices make up the logical qubit, while \u201cmeasure\u201d qubits at the center of each square are used for so-called \u201cstabilizer measurements.\u201d These measurements tell us whether the qubits are all the same, as desired, or different, signaling that an error occurred, without actually revealing the value of the individual data qubits.\n<\/p>\n

\nWe tile two types of stabilizer measurements in a checkerboard pattern to protect the logical data from bit- and phase-flips. If some of the stabilizer measurements register an error, then correlations in the stabilizer measurements are used to identify which error(s) occurred and where.\n<\/p>\n\n\n\n\n
<\/a><\/td>\n<\/tr>\n
Surface-code QEC. Data qubits (yellow<\/b>) are at the vertices of a checkerboard. Measure qubits at the center of each square are used for stabilizer measurements (blue squares<\/b>). Dark blue squares check for bit-flip errors, while light blue squares check for phase-flip errors. Left<\/b>: A phase-flip error. The two nearest light blue stabilizer measurements register the error (light red<\/b>). Right<\/b>: A bit-flip error. The two nearest dark blue stabilizer measurements register the error (dark red<\/b>).<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

\nJust as Bob\u2019s message to Alice in the example above became more robust against errors with increasing code size, a larger surface code better protects the logical information it contains. The surface code can withstand a number of bit- and phase-flip errors each equal to less than half the distance<\/em>, where the distance is the number of data qubits that span the surface code in either dimension.\n<\/p>\n

\nBut here\u2019s the problem: every individual physical qubit is prone to errors, so the more qubits in a code, the more opportunity for errors. We want the higher protection offered by QEC to outweigh the increased opportunities for errors as we increase the number of qubits. For this to happen, the physical qubits must have errors below the so-called \u201cfault-tolerant threshold.\u201d For the surface code, this threshold is quite low. So low that it hasn\u2019t been experimentally feasible until recently. We are now on the precipice of reaching this coveted regime.\n<\/p>\n

Making and controlling high-quality physical qubits<\/h2>\n

\nEntering the regime where QEC improves with scale required improving every aspect of our quantum computers, from nanofabrication of the physical qubits to the optimized control of the full quantum system. These experiments ran on a state-of-the-art 3rd generation Sycamore<\/a> processor architecture optimized for QEC using the surface code with improvements across the board:\n<\/p>\n