Modular and Efficient Surgery

Code surgery is a method for fault-tolerantly measuring logical operators of any LDPC code. When supplemented with prepared magic states, this is sufficient for universal, fault-tolerant quantum computation using Pauli-based computation. It is made possible by measurement gadgets – auxiliary systems that are combined with the code block to reduce high-weight logical operator measurements to a product of low-weight measurements.

The practicality of the method depends on the feasibility of implementing the gadget in hardware. Specifically, the inclusion of the gadget should not significantly increase the complexity of implementation over that of the code block itself. This ensures that any hardware platform capable of implementing the code will naturally also support the gadgets. Simultaneously, they should also maintain the low overhead that justifies the use of high-rate LDPC codes over alternatives such as the surface code.

This motivates two criteria that should be met for gadgets to be suitable for use in real quantum computing architectures — modularity and efficiency. In our new preprint, we present the first gadgets that simultaneously satisfy both of these criteria.

Modularity

By modularity, we mean that the gadgets should only need to be engineered once and then be  reusable indefinitely through any computation. Many past designs fail this test, since they require bespoke gadgets to measure each of the exponentially large number of logical operators. This would necessitate wholesale reconfiguration of qubits for each logical measurement. This is particularly problematic since the adaptive nature of Pauli-based computation means that the logical measurement sequence for an algorithm cannot be predetermined. Instead, an entirely different quantum circuit would need to be calculated and implemented in real-time for each logical measurement cycle. We are not convinced this level of control is achievable in practice.

We achieve modularity by instead designing a system consisting of a small number of essentially fixed gadgets. By docking these gadgets onto different sites of the code block, we can measure any logical operator. For example, we show how cyclic shifts of just four gadgets suffice to measure any logical operator on a family of generalised bicycle (GB) codes. The control problem is thereby reduced to a simple input of how many sites each gadget should be shifted before docking.

The following video shows an example of measuring a random sequence of logical operators on a GB code using our gadget system. Black and grey dots represent data and ancilla qubits and the lines connecting these to gadgets show where the gadget is connected. The lines connecting the gadgets represent bridges. Notice how all that changes for each logical operator is that the connection sites for each gadget are shifted. Replacing dynamic rewiring within gadgets with this “plug and play” operation makes LDPC code surgery a much more realistic prospect!

Efficiency

By efficiency, we mean that the gadgets achieve order-of-magnitude spacetime reductions over surface code lattice surgery. This criterion is crucial, since overhead reductions are the reason to prefer LDPC codes over surface codes. Designing gadgets with low space overhead was achieved by previous work. However, recent work has raised questions about the time overhead. In particular, IBM Quantum’s recent preprint Tour de gross applied the extractor formalism to design the first modular gadget system for a practical LDPC code. However, the gadget system they present cannot measure an arbitrary logical operator in a single logical measurement cycle (only a generating set). Overcoming this limitation requires compilation that increases the time overhead for universal fault-tolerant quantum computation by an order of magnitude. As a result, there is no substantial spacetime saving over the surface code, only a tradeoff of time and space.

By contrast, our gadgets are efficient as they maintain a low space overhead without any corresponding increase in the time overhead. This is because they allow measurement of any logical operator in a single logical cycle (i.e., d rounds of syndrome extraction), removing the need for additional compilation. LDPC codes have long been asserted to give order-of-magnitude overhead reductions. Our gadgets make this promise real by manifesting such spacetime reductions in a concrete, modular design.

More to Come

Our modular, efficient gadgets demonstrate a realistic construction to achieve the promise of low-overhead quantum computing with LDPC codes. However, they are not the end of the story. In the future, we look forward to synthesising this work with last month’s development of fast surgery to design modular gadgets that achieve order of magnitude reductions in both space and time overhead compared with surface codes. We are also excited to apply our construction to a wider range of LDPC codes tailored to meet the needs of different hardware platforms, and to integrate it into a fully fledged fault-tolerant architecture. While surface code architectures have been heavily optimised already, the LDPC code architectures of today are at the very start of what’s possible, and much remains to be explored, tried and built. By combining new discoveries with practical design for real hardware, we look forward to accelerating the onset of useful quantum computers further.