Fast Surgery

Quantum computers offer exponential speedups for certain problems, promising to unlock new frontiers of computation that will remain forever out of reach to classical computers. But actually running a quantum computer is slow. The time it takes to perform one logic gate, its logical clock speed, is orders of magnitude slower than on a classical computer.

On top of this, discussions of quantum speedups often overlook that most high-value algorithms require extremely long circuits. Executing these within a realistic runtime is challenging (and for some hardware platforms effectively impossible) with current methods. Improvements in logical clock speed are therefore essential to make such algorithms practically and economically viable.

Why is the logical clock speed so slow?

Partly because the underlying physical operations are simply slower. A modern classical chip can perform a logic gate in about one picosecond, while some quantum hardware platforms take tens or even hundreds of microseconds for each elementary physical operation.

But raw physical speed isn’t the full story. Useful quantum computation relies on logical qubits — collections of many physical qubits encoded within quantum error correcting codes to protect against the inherently higher noise of quantum devices. The logical clock speed is ultimately set by how fast we can perform logical operations on these encoded qubits, and the procedures required to do so fault-tolerantly often introduce additional large time overheads.

In our recent preprint, we introduce Fast Surgery, a new method that removes one of the major time overheads in fault-tolerant quantum computing and makes possible a 15-30x speedup for useful quantum algorithms. It is a concrete step toward realising both hardware- and time-efficient, utility-scale quantum computing, and a significant advance for the broader LDPC code paradigm.

In this post, we give a short summary of what we did and how it works.

Compressing logic

One of the most popular methods for performing fault-tolerant logic is by making measurements of logical qubits. The main technique for performing these measurements is known as surgery, and was first developed for surface codes before being generalised to quantum LDPC codes. Surgery works by carefully attaching and detaching a set of auxiliary qubits to the error-correcting code. After detaching these qubits, we physically measure them to infer the outcome of the logical measurement. But when noise is present, each of these physical measurements incurs some probability of being flipped. If any physical measurement is flipped, then our logical measurement is also flipped, rendering it useless. To alleviate this, traditional surgery schemes perform multiple rounds of the surgery operation. The number of rounds needed is more than an order of magnitude for large fault-tolerant algorithms (typically 15–30 in practice). This introduces enough redundancy to the scheme to correct measurement errors, at the cost of a significant increase in time spent.

Fast Surgery is designed to reduce the amount of time needed to perform logic by extracting reliable logical measurements in just a single round. The key insight behind Fast Surgery is that the redundancy needed for fault tolerance doesn’t have to come from repeating operations in time, it can instead be drawn directly from the structure of the code itself. In an error-correcting code, logical information is stored in a distributed way across many physical qubits, meaning there are multiple, equivalent representations of any logical operator. Fast Surgery exploits this fact; rather than performing the same measurement several times to gain redundancy, we can measure several representations at once. This transforms time redundancy into spatial redundancy, compressing many sequential rounds into one parallel operation.

To achieve this, we construct an auxiliary system of qubits that couples simultaneously to all these equivalent representations. This auxiliary system need to be carefully constructed to ensure that the error correcting capabilities of the code are not affected during the procedure. We find a sufficient set of conditions (and an associated constructive scheme) to ensure that the distance of the error correcting code is preserved. When we detach and measure these auxiliary qubits, we obtain a set of correlated outcomes that collectively provide the same level of fault tolerance that previously required many rounds of repetition. The result is a fully fault-tolerant measurement that completes in a single logical cycle.

To evaluate the performance of fast surgery we ran numerical simulations comparing it to the most widely used standard surgery scheme for quantum LDPC codes. We simulated a small distance 3 multi-cycle code, suitable for early fault-tolerance demonstrations. The aim was to test whether a single-round implementation could still achieve fault-tolerant behaviour.

Let’s unpack these results a bit. On the x-axis, we plot the physical error rate, how often the hardware itself makes mistakes during basic operations like measurements. On the y-axis, we plot the logical error rate, how often the encoded information fails despite the protection of the error-correcting code. The dashed, black line represents the pseudo-threshold, the point where the logical error rate matches the physical one. Any points above this line are performing worse than if we hadn’t used error correction at all. Points below the line represent the region where error correcting is improving the reliability of our computation. For practical schemes we want to be firmly below this line.

When we attempt to perform a logical measurement using just a single round of standard surgery the logical error rate remains too high to cross the pseudo-threshold line. Standard surgery only starts to work when we repeat the measurement several times. Fast Surgery, on the other hand, achieves fault-tolerant performance in a single round. In our simulations it performs better than standard surgery, even when the latter is repeated several times. Because Fast Surgery requires fewer rounds of measurement, it reduces the overall execution time and limits the accumulation of other errors. This time compression directly improves logical performance, showing that redundancy drawn from the code structure can effectively replace redundancy in time.

Another step forward for LDPC codes

This work builds on earlier advances in making LDPC codes practical for quantum computation. A few years ago, we introduced the first generalised surgery framework for LDPC codes, which brought the leading way of doing logic in surface codes to the LDPC setting. Fast Surgery goes a step further: it shows that LDPC codes can now perform these operations both faster and more efficiently than existing surface code schemes. We’re excited about what this unlocks and look forward to sharing further advances soon.