Bicycle Race: small two-block codes on the Pareto frontier

AI summary

Overview

Research area: Quantum error correction — specifically quantum LDPC codes built from group algebras (two-block codes, which generalize bivariate bicycle and generalized bicycle codes).

Technical level: Advanced. The summary is readable, but the paper assumes familiarity with stabilizer codes, check weights, code distance, and the [[n, k, d]] notation.

Scope: A systematic, largely laptop-scale census and search of small two-block group-algebra codes (up to 320 qubits, check weights five to nine) to determine how close this simple code family comes to the Pareto frontier, and where in the space of finite groups good codes actually live.

What This Paper Is About

Two-block group-algebra codes are among the simplest quantum LDPC codes, and many of them are translation invariant on a twisted torus — a property that suits platforms with movable qubits such as neutral-atom arrays. Recent work has assumed that these simple codes lose to more elaborate lifted-product constructions in raw parameters. This paper asks how far two-block codes actually go at small sizes when searched systematically across all finite groups instead of sampled ad hoc, and along the way maps out which group structures produce good codes.

Key Contributions

1. A search pipeline that makes broad enumeration tractable. Algebraic reductions (two-sided translations, group automorphisms, antipode with block swap, shared-factor and rank/ideal targeting) plus sound screens on k and d let the author census about 10^8 two-block codes with up to 320 qubits at check weights five to nine, on two laptops with no GPU or cluster time.
2. Exhaustive censuses and complete statements. Exhaustive search is reported for weight five up to n = 300, weight six up to n = 300, weight eight up to n = 100, and weight nine up to n ≤ 94. These support complete claims such as: the Gross code is, up to equivalence, the only abelian weight-six two-block code with n ≤ 200 to reach kd²/n = 12; no weight-six two-block code with n ≤ 300 beats [[288,16,16]]; and the known [[64,18,8]] is the best two-block code by kd²/n across weights five to nine with n ≤ 94.
3. New codes along the Pareto frontier. Highlights include the weight-nine codes [[102,20,10]], [[120,24,10]], [[186,20,18]] (every check in a 5×5 window), [[126,16,14]], [[150,24,13]], [[210,28,16]], [[270,72,6]] and [[294,36,16]]; the weight-eight [[292,22,23]] at kd²/n = 39.9; and the non-abelian [[294,24,21]] at kd²/n = 36.0. At check weights seven to nine, the best codes found exceed the best published kd²/n with exact distance at the same check weight in most length bands up to 320 qubits.
4. An empirical map of where good codes live, plus a public database. Good codes concentrate in a handful of groups; abelian groups win at small n and non-abelian groups at large n, with the crossover moving outward as check weight grows. This observation steered a targeted sampling routine that finds four to fifteen times as many good codes as uniform draws in equal time.

Main Findings

• Exhaustive benchmarks hold up. The weight-six census is complete enough to state that the Gross code is the unique abelian weight-six two-block code with n ≤ 200 reaching kd²/n = 12, and that [[288,16,16]] is unbeaten by any weight-six two-block code with n ≤ 300.
• Weight five and six are genuinely non-abelian-friendly at small sizes. Exhaustion over all groups up to n = 300 for weight five shows non-abelian codes such as [[288,4,20]] really do have better parameters, so this is not a sampling artifact.
• Abelian versus non-abelian is size dependent. For weight nine, the best non-abelian code [[294,24,21]] over a non-abelian group of order 147 ties the abelian [[288,32,18]] at kd²/n = 36.0. Across the four length bands, the best non-abelian kd²/n is 0.44, 0.67, 0.73 and 1.00 of the best abelian value — the gap closes with n.
• Good codes get much rarer as check weight rises. Against the author's own best code at each check weight, a uniformly drawn code comes within 80% of it a hundred to a thousand times less often at weights eight and nine than at weight six.
• Weight nine is underexplored, not intrinsically weak. Of the CSS codes with n ≤ 320 in the literature set, 826 have check weight eight but only 19 have weight nine, all from 2026. The author attributes this partly to practicality and partly to search cost: per group of order 100 there are 5.9 × 10^11 candidate block pairs containing the identity, and up to n ≤ 200 there are roughly 10^17 possible pairs at weight nine.
• The search space is large but not hopeless. For n ≤ 200 there are 183 abelian and 863 non-abelian groups; reductions and screens cut this to a size where exhaustive search is possible in several bands.
• Weight eight is competitive but strongly anchored. The [[292,22,23]] code reaches kd²/n = 39.9, the highest among the weight-eight codes found; the coset code [[306,22,24]] from the literature has the same k on 14 more qubits and reaches 41.4. The band anchor is the pair-partition [[232,62,12]] at 38.5, which sits at almost three times the rate.
• Weight-nine highlights span rate and distance. [[102,20,10]] and [[120,24,10]] operate at rate roughly 1/5; [[270,72,6]] over C45 × C3 encodes 72 logical qubits at rate 0.27; [[294,36,16]] sits in between.
• Circuit-level simulations look promising. Using brute-force syndrome-extraction circuits (circuit distance 8, one ancilla per check, 10 rounds, depolarizing noise at gates, preparation and measurement only, Relay-BP decoder), [[102,20,10]] reaches per-logical-per-round p_L ≈ 2 × 10^-6 at p = 10^-3, and [[120,24,10]] about 4 × 10^-7. The larger code stays below the smaller by about 6× at p = 10^-3, 2–4× for p = 1.5–3 × 10^-3, shrinking to 1.1–1.4× near break-even. Break-even is at p ≈ 0.57% and 0.62% respectively.
• Structural gift for atom movers. On a twisted torus every check is a translate of one stencil, so qSieve-style scheduling applies: at most four rigid translations per stencil vector and only two transfers between static and mobile traps, with qSieve timing such schedules at 3–6 ms on ordinary tori.
• CSS-only caveat. Non-CSS codes appear to far outperform the best CSS codes on these metrics; this search stages only against the best CSS codes but notes where non-CSS codes sit.
• Hardware footprint of the research itself. All computations ran on two laptops — an Apple MacBook Pro with an M5 chip (10 CPU cores, 16 GB memory) and a 2020 13-inch MacBook Pro with an Intel Core i5-1038NG7 (4 cores, 8 threads, 2.0 GHz, 16 GB memory) — with up to 8 worker processes, no run exceeding about 8 hours, and no GPU or cluster time.

Methodology in Plain English

A two-block code is specified by a finite group G and two group-algebra elements a and b, giving n = 2|G| qubits split into left and right blocks. The check matrices use the left and right regular representations, which commute by construction, so the code is valid automatically. The search therefore reduces to enumerating groups and block pairs.

The pipeline works in stages. First, a target is chosen: a check weight (five through nine) and a length band (n ≤ 130, 130 < n ≤ 170, 170 < n ≤ 220, 220 < n ≤ 320). Within each band an anchor is fixed — the best CSS code in the literature for that weight and band by kd²/n, for example from the Lin–Pryadko census, pair-partition codes, coset codes, covers, or mitten codes. The identity is fixed to appear in each block, then the remaining elements are sampled.

Second, candidates are reduced up to equivalence: two-sided translations of each block (cutting classes by up to 4 × 10^3), group automorphisms (up to 3 × 10^2), and antipode with block swap or X ↔ Z interchange (about 2×). Additional reductions target shared factors in abelian components and ranks or ideals in simple and non-simple components.

Third, cheap sound screens reject codes that provably cannot match the anchor: connectivity, k from annihilators, odd-weight blocks over 2-groups, and hypergraph-product detection.

Fourth, distance is computed as a sandwich — a randomized estimator working downward and an exact calculator working upward, with pruning bounds and symmetry roots — and codes are discarded as soon as they cannot reach the anchor. Survivors within 90–100% of anchor parameters are shortlisted, deduplicated via canonical keys on the Tanner graph using pynauty, and given exact distances, with witnesses kept for every reported distance. The best codes with d ≲ 15 were independently confirmed with dist-m4ri, with further cross-checks from QDistRnd and QDistEvol.

Finally, the winners from the first uniform pass were inspected for common structure. Since they clustered by group type, later rounds shifted time toward groups with guaranteed nonzero k (abelian) or with explicit lower bounds on k (non-abelian), while keeping some uniform sampling running. The reported yield gain from this steering is four to fifteen times. All code was written in Python with numba, following a hand-written plan with human and soundness gates; Claude was used for literature review, and every citation was checked by hand.

Why This Matters

The paper argues that the standard narrative — simpler codes must have worse parameters — does not hold in the small-code regime. By rebuilding a Pareto frontier from a family that is easy to lay out, easy to decode with matching, and friendly to movable-qubit hardware, it gives experimentalists a realistic set of small codes rather than only asymptotically attractive ones. It also provides a benchmark database and an empirical theory of which groups produce logical qubits, while explicitly leaving the complementary question — why some groups produce large distance — open.

Real-world applications:

• Neutral-atom arrays with optical tweezers/AODs, where long-range checks are cheap, crossings are immaterial, and minimizing atom transfers matters because transfer is among the noisiest steps.
• Trapped-ion systems with movable ions, which the paper cites alongside atoms as a reason long-range checks have become practical.
• Quantum memory and logic architectures that exploit translation automorphisms to shuttle logical information into fixed measurement zones, as in IBM's Gross-code-based architecture.
• Code selection and benchmarking, where the (n, k, d) Pareto front and public database let hardware teams compare candidate codes on equal footing.

Industry relevance: the work directly engages with the Gross code

Authors’ abstract

Two-block group-algebra codes are among the simplest quantum LDPC codes, and many of them are translation invariant on a twisted torus, which suits neutral-atom arrays and other platforms with movable qubits. We ask how far they go at small sizes when searched systematically across all groups. We use algebraic constraints and screens to design a search pipeline capable of enumerating broad and complete swathes of two-block codes on a laptop. With it we census about $10^8$ two-block codes with up to $320$ qubits at check weights five to nine. Several of these censuses are exhaustive, and support complete statements; for instance, the Gross code is, up to equivalence, the only abelian weight-six two-block code with $n \le 200$ to reach $kd^2/n=12$, no weight-six two-block code with $n \le 300$ beats $[[288,16,16]]$, and the known $[[64,18,8]]$ is the best two-block code by $kd^2/n$ across weights five to nine with $n \le 94$. The censuses are also large enough to give insights into where good codes live - they concentrate in a handful of groups; abelian groups give the best codes at small $n$ and non-abelian groups at large $n$, with the crossover appearing to move out as the check weight grows; and high quality codes become $100$ to $1000$ times rarer per draw from weight six to weights eight and nine. Using the group algebra and the census data to steer a statistical search finds four to fifteen times as many good codes as uniform draws in equal time. Among the codes found are $[[102,20,10]]$ and $[[120,24,10]]$ at check weight nine, which we simulate in noisy syndrome-extraction circuits, and $[[186,20,18]]$, a weight-nine code with every check in a $5\times5$ window. At check weights seven to nine, our best codes exceed the best published $kd^2/n$ with exact distance at the same check weight in most length bands up to $320$ qubits. All codes are available in a public database.