Most of the physical-qubit cost of fault-tolerant quantum computing goes to error correction. A distance-11 rotated surface code spends 121 data qubits to protect a single logical qubit. High-rate quantum low-density parity-check (qLDPC) codes aim to protect many logical qubits per block, and recent constructions report encoding rates from about 10% to over 50%. What the field has lacked is a systematic way to explain why some constructions reach good distance at small sizes and others don’t. A new preprint by Jong Yeon Lee, Koki Okada, Nishad Maskara, Kenta Kasai and Hengyun Zhou (arXiv:2609.30069) sets out to provide one, and supports it with explicit codes and circuit-level simulations.
This article was drafted with Claude and fact-checked against the cited primary sources. All numbers below come from version 1 of the preprint, submitted on 24 September 2026. It has not yet been peer reviewed.
What the paper does
The authors split code design into five steps. First, pick a construction template: a protograph plus a lift strategy that guarantees the stabilizers commute. Then fix a design rate and choose the degree parameters: how many checks touch each data qubit (column weight) and how many qubits each check touches (check weight). Next, pick a lift size, which sets the blocklength. Finally, screen the candidates and iterate.
The framework rests on a simple counting identity. With n data qubits and r checks, counting qubit–check incidences gives n·J̄tot = r·L̄stab, so the rate is R = 1 − J̄tot/L̄stab + ρdep. The first two terms form the design rate. The last term counts extra logical qubits that come from redundant checks. The identity makes one tradeoff explicit: at a fixed design rate, average qubit degree and average check weight can’t be chosen independently. It also places bivariate bicycle codes, such as IBM’s gross code, in the zero-design-rate class. All of their logical qubits come from check dependencies, which the authors note often keeps the logical-qubit count from growing in proportion to blocklength.
The key idea: column weight is a design lever
The authors borrow two ensemble tools from classical LDPC theory: density evolution to estimate belief-propagation thresholds, and a Gallager-style weight-enumerator estimate of typical distance. Both suggest that an average data-qubit degree of two is not enough, and that at least three is usually needed. Combined with the rate identity, this gives a concrete constraint. For a basis-symmetric regular CSS code at rate 1/2, a column weight of at least 3 forces a check weight of at least 12. The authors say they expect well-performing rate-1/2 codes with a maximum check weight below 12 to be hard to design.
The less obvious claim is that pushing column weight higher often pays off, even though it forces heavier checks. In their rate-1/2 families, going from column weight 3 to 4 reaches distance 18 at n = 848 instead of n = 2676, which is 3.2× fewer qubits. The cost is a check weight of 16 instead of 12.
How it works
Pair-partition codes. Both check matrices are lifts of an all-ones J×L protograph built from circulant permutation matrices. To make X and Z checks commute, the construction groups the block columns into pairs and forces each pair to share the same exponent difference. Their contributions to HXHZT then cancel pairwise over 𝔽2. The result is a code with blocklength n = LP, check weight L, column weight J, and design rate 1 − 2J/L. The search runs in three stages: backtracking over perfect matchings, solving linear equations mod P for the exponents, and screening candidates for girth and distance. Circulant lifts carry a known distance ceiling of (J+1)!, which is 24 for J = 3 and 120 for J = 4. An affine-permutation variant removes that ceiling, but the authors find it only helps above roughly 1,000 qubits.
Symplectic halving. Any non-CSS stabilizer code can be “doubled” into a CSS code on twice as many qubits, and the authors run this map in reverse. If a CSS parent has a fixed-point-free qubit pairing that swaps its X and Z check spaces, each pair can be folded into one qubit. The result is a non-CSS code on half the qubits with the same rate, no heavier checks, and a distance between ⌈d′/2⌉ and d′. The authors impose the halving condition at the start of the search instead of hoping it appears. This also shrinks the search space. At matched (J, L), halved codes reach a given distance with a median 1.6× shorter blocklength. The headline instances come from this construction: [[90,21,11]], [[140,31,15]] and [[200,43,20]], all with check weight 10.
What the results show
Parameters. For comparison, IBM’s gross code (Bravyi et al., Nature 2024) is [[144,12,12]]. The halved [[140,31,15]] code is about the same size, encodes more than twice as many logical qubits, and has a larger distance.
Encoding efficiency. On the figure of merit kd²/n, where the surface code scores 1, bivariate bicycle codes sit around 25. Recent ZSZ-LP/Mitten codes reach about 100 near n ≈ 800. The CSS pair-partition codes reach about 100 near n ≈ 370, and the halved codes just above n = 200. Restricted to check weights 8–10, a halved code reaches kd²/n = 112 at n = 245.
Circuit-level memory. The simulations use 0.1% depolarizing noise, 20 syndrome rounds, and a hierarchical decoder (BP, then relay-BP, then integer programming). The [[95,22,11]] code had 10 failures in 3.73×108 shots, about 6.1×10−11 per logical qubit per round. A distance-11 rotated surface code under the same noise model gave 5.6×10−9. The authors describe this as a better per-round logical error rate with 28× fewer qubits for the same number of logical qubits. A [[186,65,14]] code had no failures in 5.58×108 shots, which puts an upper bound of 4.1×10−12 on its per-logical-per-round rate.
Distance vs. check weight. Two codes of similar size were compared at 0.1% noise: [[530,216,12]] with check weight 10 and [[518,228,16]] with check weight 14. Their per-round logical error rates were 2.1×10−9 and 1.5×10−10 respectively, so the heavier-check code won.
Logical bases. A symmetry-based “packet” decomposition of the logical space finds low-weight, canonically paired logical operators. For a [[184,50,10]] code, the best basis had a mean representative weight of 12.6, against about 20 for generic basis construction followed by coset minimization.
Why it matters
Qubit counts decide what fits on near-term hardware. A 95-qubit block that stores 22 logical qubits at distance 11 is the kind of object that reconfigurable neutral-atom or trapped-ion platforms could plausibly host. The authors name both platforms as targets. The paper’s more lasting contribution may be its method. It gives common coordinates (template, degree distribution, lift size) for comparing code families, and a clear test: at fixed row and column weights, a better family reaches a target distance at a smaller blocklength.
A technical perspective
This section is my interpretation, not a claim made by the authors. The finding that heavier checks can win pushes back on the instinct to minimize check weight at any cost. It depends on the regime, and the paper says so. The authors’ crossover estimate assumes the threshold scales as 1/(check weight), anchored to a roughly 0.7% threshold reported for Mitten codes. On that estimate, the lighter-check code becomes preferable above about 0.19% physical error, and 0.1% sits only about 2× below that crossing. Hardware operating nearer 0.2% could land on the other side. The halved codes are also non-CSS, so they give up transversal X/Z-basis preparation, readout and CNOTs. The authors point to code surgery, which works for non-CSS codes too, as the route to computation. Its overheads are still unquantified here.
Limitations and open questions
Noise model. The simulations exclude idling errors, and the non-CSS memory runs assume noiseless state preparation and final readout. The authors say more careful accounting is needed.
Upper-bound distances. Several reported distances are upper bounds (marked ≤ in the tables). The kd²/n comparison uses quoted distances for every family, including competitors, and some of those are also upper bounds.
Heuristic ensemble tools. The density-evolution analysis ignores CSS orthogonality and the pair-partition constraints. The ensemble distance estimate deviates noticeably from actual code distances.
Decoding cost. The integer-programming decoder stage becomes very expensive at 0.2% noise, so the predicted crossover was not verified directly. Heavier checks also lengthen syndrome cycles and increase decoding time.
Logical operations. Surgery overheads and architecture-level tradeoffs are left to future work.
Data. The paper points to a supporting data repository, which was still empty when I checked on 25 September 2026.
Paper information
Title: Design Principles for Ultra-High-Rate Quantum Codes
Authors: Jong Yeon Lee (UIUC; KIAS), Koki Okada (Institute of Science Tokyo), Nishad Maskara (MIT), Kenta Kasai (Institute of Science Tokyo), Hengyun Zhou (MIT). Lee and Okada contributed equally.
arXiv: 2609.30069 [quant-ph], v1 submitted 24 September 2026
Length: 20 + 16 pages. The preprint incorporates the earlier arXiv:2607.14091 by Okada and Kasai.
Status: preprint, not peer reviewed
Primary sources
Lee, Okada, Maskara, Kasai, Zhou, “Design Principles for Ultra-High-Rate Quantum Codes”: arXiv abstract · full text (HTML)
Okada, Kasai, “Pair-Partition Constructions for CPM-Based Quantum LDPC Codes”: arXiv:2607.14091
Bravyi et al., “High-threshold and low-overhead fault-tolerant quantum memory,” Nature 627, 778–782 (2024): doi:10.1038/s41586-024-07107-7
Supporting data repository (listed in the paper): github.com/ultra-high-rate-qec/design-principles-data