Lifted Surgery

Last year we introduced fast surgery, a general technique for speeding up logical gates in QLDPC codes. We have now developed lifted surgery, a concrete realisation of fast surgery for general group algebra codes.

Group algebra codes are a diverse family of codes that are capable of achieving very good finite-length performance. As a result, they form the bedrock of almost all existing QLDPC-based fault-tolerant architectures. The generalised bicycle codes used in the first version of the Pinnacle architecture, the bivariate bicycle codes used in IBM’s bicycle architecture, the codes used in IonQ’s walking cat architecture, and the lifted product codes used in Oratomic’s resource estimate are all examples of group algebra codes.

Group algebra codes also possess large amounts of symmetry, which makes it much easier to design circuit schedules for them across a range of different hardware platforms. When designing lifted surgery, one of our motivations was to preserve this symmetry, and we will release some further results soon on how this helps us design good hardware layouts for fast surgery.

To preserve the symmetry of the codes, we made two concrete choices when designing lifted surgery. First, we use an identical copy of the base code as the surgery auxiliary system. This also ensures that the auxiliary system has the error-correction properties required to operate as a fast auxiliary system. Second, we only connect the auxiliary system to the base code in specific ways, such that the resulting merged system is also given by a group algebra code.

Fixing these two choices allowed us to give a rigorous mathematical treatment of lifted surgery. We showed that group algebra codes naturally decompose into blocks of logical qubits. Lifted surgery is able to act block-by-block to perform logical measurements. We identify three types of blocks, distinguished by how much addressability they allow:

• Coarse blocks where we can either measure all the logical qubits in the block, or none.
• Fine blocks where we can measure certain subsets of logical operators.
• Completely fine blocks where we can measure any subspace of logical operators of the same type in parallel.

This last block is extremely powerful. For these blocks we can not only perform logical measurements with only one round of syndrome extraction, we can perform a large set of logical measurements at once, all with just one round of syndrome extraction. This combines the advantages of fast surgery with those of parallel/high-rate surgery.

We also define several sub-families of Lifted Surgery, which allow us to achieve nice properties for specific sub-families of group algebra codes:

• Scalar surgery allows us to obtain a merged system large amounts of structure, making it ideal for implementing on physical hardware.
• Lifted product surgery utilises the underlying product structure of certain group algebra codes, allowing us to design surgery operations with lower connectivity requirements.

We were able to find several examples of codes with highly addressable logical via lifted surgery. For example, we find a code that requires a total of 198 data qubits (396 physical circuit qubits) to encode 8 logical qubits at a distance of 16, which consists of one completely fine block. This means we can measure any combination of the 8 logical operators of the code quickly and in parallel. These represent a 10x improvement in the space overhead compared to surface codes, while maintaining all the speed of fast surface code operations implemented via transversal gates. Compared to standard, sequential QLDPC surgery these examples represents a potential 50x speedup.

It’s not enough to just perform logical measurements on isolated codes. We also need to be able to perform joint measurements across several codes. To address this we also designed a method for bridging lifted surgery systems. When we have two copies of the same code we can connect them with an auxiliary system, which consists of a single copy of the base codes. As above, the amount of addressability depends on the code used and the block decomposition. For example, for the distance 16 code we can bridge any logical qubit in the first code with any logical qubit in the second code. In fact, we can pairwise bridge any set of r logical qubits in the first code with any set of r logical qubits in the second code.

To assess the performance of lifted surgery we ran simulations of several different experiments, including scalar surgery, sequences of surgery operations on completely fine blocks and bridged lifted surgery between codes. While the physical circuits are all LDPC, the meta-checks that make lifted surgery fast can often be quite, resulting in dense decoding matrices. We developed a a new two-pass sparsifying decoder to address this. The decoder uses two optimisations to reduce the complexity of the decoding problem. First, it splits the decoding matrix into two seperate matrices, one for X detectors and one for Z detectors. It first decodes the X detector matrix, and then uses that information to update the priors for the Z decoding matrix. This is a similar technique used for correlated matching in the surface code. The second optimisation is to sparsify the decoding matrices using an information set algorithm. We search for low weight vectors in the row spaces of each decoding matrix and use these to construct new sparse matrices with the same row spaces as the original decoding matrices. We decode on these sparse matrices, and convert the corrections back to the original decoding matrices to make logical predictions.

Our simulations show that lifted surgery is capable of reaching utility-scale performance. With a code consisting of just 90 data qubits (180 physical circuit qubits) at physical error rates of 0.1% we can already reach the 0.0001% failure rate per logical operation needed for early fault-tolerant simulations in materials science. For the distance 16 code we took millions of shots of a lifted surgery operation and found no logical failures. We also ran simulations of bridged lifted surgery and found that performance was identical to lifted surgery on single codes.

We have already begun integrating lifted surgery into the next version of Pinnacle. This involves optimising the code choices and surgery operations for the target logical failure rates; optimising the syndrome extraction circuits across the different hardware platforms; and optimising algorithmic compilation to fully utilise the parallelism made available by lifted surgery. We expect lifted surgery to become a core part of Pinnacle going forward, substantially reducing logical runtimes across a wide range of applications.