Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

arXiv:2610.05307

Lifted surgery for non-Abelian two-block group-algebra codes

Tushar Pandey

quant-phSubmitted Oct 4, 2026• Announced Oct 6, 2026• 1 citation
arXivHTMLPDF

Abstract

Code surgery measures a logical operator of a quantum LDPC code with $O(d)$ rounds of syndrome extraction. Lifted surgery amortises this cost on Abelian group-algebra codes by measuring an orbit of logical operators under a translation symmetry in one merged code. We extend it to two-block group-algebra codes over non-Abelian groups and ask whether non-commutativity lets one merged code measure more operators than any Abelian group of its symmetries. We classify the block-affine automorphisms of these codes and find that, measured against this full group, most apparent non-Abelian gains disappear. We prove that the gain is at most the index of a largest Abelian subgroup. We find codes with exact distance up to $13$ where the gain is two, including codes in which one merged code reads out every logical qubit, and codes over products of $A_4$, $S_4$ and SL(2,3) with gain three for a best logical, up to $[[336,26,12]]$. A merged-distance lemma gives a simple condition for the gadget to preserve the code distance. In circuit-level simulations with Relay-BP decoding, at the error rates we can resolve, the non-Abelian gadget is as reliable as, or more reliable than, the Abelian gadgets it replaces within statistical error, while using two to three times fewer rounds.

AI Summary

Can non-Abelian symmetries increase the number of logical operators measured in one lifted-surgery gadget beyond what Abelian symmetries allow? This paper extends lifted surgery to non-Abelian two-block group-algebra codes, comparing disjoint, logically independent translates of a chosen logical under the full block-affine automorphism group $E$ with those under its Abelian subgroups. It classifies Tanner-level block-affine automorphisms under a support-stabiliser hypothesis and develops rigidity criteria. Twisted translations and outer automorphisms eliminate many apparent advantages over translation-only baselines. The remaining gain satisfies $\gamma(v)\le\min_{H\le E\text{ Abelian}}c_H(v)\le[E:H_{\max}]$, where $c_H(v)$ counts distinct translates of the Abelian orbit. Exhaustive automorphism searches, exact co-measurability optimisation and distance certification establish gain two in eleven codes with distances $6$–$13$; four permit simultaneous readout of every logical qubit. Sixteen further codes have best-logical gain at least three, including $[[336,26,12]]$ and one gain of $10/3$. A merged-distance lemma preserves both CSS distances when each ancilla graph has Cheeger constant at least one. Circuit-level depolarising-noise simulations with Relay-BP decoding find two-to-threefold reductions in merged rounds relative to the selected Abelian gadgets, without statistically resolved reliability loss at the tested error rates. The comparison excludes automorphisms outside the block-affine class and unrestricted symmetry-free parallel surgery. Gains depend on the chosen logical; some code-level comparisons cover only logical orbits found. Simulations probe measured $Z$ outcomes near pseudo-thresholds, not unmeasured-qubit damage or full fault distance. Higher-distance persistence, lower-error performance and operational benefits of symmetry-adapted ancillas remain open.

No sign of AI-generated textMissing comparison

Error found: For the simulated [[108,16,6]] code, the advertised factor-two round reduction uses a four-operator Abelian baseline even though an Abelian translation subgroup can measure eight operators, so this example does not demonstrate a speedup over the full Abelian baseline.

Written by gpt-6.1-sol from the paper's full text. Automated: it can be wrong.

Comments
25 pages, 3 figures, 8 tables

Related papers

Lifted surgery: Fast processing with QLDPC codes

Lucas Berent, Lawrence Z. Cohen, Armanda O. Quintavalle

Quantum low-density parity-check (QLDPC) codes are a leading candidate for achieving low-overhead fault-tolerant quantum computing. However, the time overhead of logical operations in QLDPC codes remains a key challenge. Code surgery, a space-efficient technique for fault-tolerant logical measurements, incurs this overhead through repeated rounds of syndrome measurement. We introduce lifted surgery, a method for fast and parallel surgery on Abelian group algebra codes that maintains the low physical overhead that makes QLDPC codes attractive. Lifted surgery preserves the symmetries of the underlying code, making searches for large instances tractable and offering a natural route towards efficient hardware implementations. We utilise block decompositions and techniques from commutative algebra to characterise lifted surgery, investigate well-behaved subfamilies, and construct explicit examples. In particular, we present quantum radial codes with parameters $[[90, 8, 10]]$ and $[[198, 8, 16 ]]$ for which surgery is fast, parallel, and addressable, allowing arbitrary sets of independent logical operators of the same Pauli type to be measured in a single round of syndrome extraction. We benchmark lifted surgery under circuit-level depolarising noise and, for the $[[ 90, 8, 10 ]]$ code, find logical performance comparable to standard code surgery while requiring ten times fewer rounds of syndrome measurement. By combining speed and parallelism, lifted surgery offers a practical route towards low-overhead fault-tolerant quantum computing.

quant-pharXiv:2609.11723•Sep 11, 2026•9 citations

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

Gideon Lee

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.

quant-pharXiv:2610.13880•Oct 12, 2026•1 citation

Logical Spectroscopy: Lifted-Product Codes with Addressable Bases

Jong Yeon Lee

Quantum LDPC memories can encode many logical qubits, but that alone does not make them usable: applications need to know where the logical operators are supported, how they are labeled, and how conjugate $X/Z$ partners pair. For hypergraph-product codes this information follows from row reduction over $\mathbb{F}_2$. For Abelian lifted-product codes, which include prominent high-rate constructions, it does not: the entries of the defining seed matrices live in a group algebra rather than a field, so pivots need not be invertible and row reduction can fail. To address this problem, we introduce \emph{logical spectroscopy}. For an odd-order Abelian lift group, the Chinese remainder theorem splits the group algebra into finite fields, one for each Frobenius orbit of characters; we call these orbits packets. Packet by packet, we solve ordinary finite-field linear algebra, lift the answers back to the physical code with the associated packet projectors, and pair $X$ and $Z$ logicals between reciprocal packets by trace duality. The result is a complete conjugate logical basis for a finite Abelian lifted product code that is addressable: every logical coordinate carries canonical packet and Künneth-summand labels, deterministic within-block indices, a conjugate partner, and an explicit binary representative. The code's own translation symmetry then acts on these coordinates in closed form. We apply the construction to examples with up to 5000 physical qubits, including high-rate examples whose distance-witness is reported explicitly. We further extend the decomposition to even-order lifts. Logical spectroscopy thus equips Abelian lifted products with an explicit logical coordinate system and an algebraic toolkit for high-rate code search.

quant-pharXiv:2607.05386•Jul 7, 2026•10 citations

Lifting Lifted Product Codes

Yuta Hirasaki, Jong Yeon Lee

Lifted product (LP) codes form an important class of quantum error correcting codes with favorable code parameters. We introduce a systematic construction of LP code families based on group extensions and graph lifts. The construction increases the code size while preserving the local structure of the Tanner graph, and relates code parameters, logical operators, and fault-tolerant logical-operation gadgets within the families through chain and cochain maps. As a first application, we obtain LP codes with better code parameters than previously reported ones. We then demonstrate that code-surgery gadgets can be transferred across the selected finite lifts through chain maps and, in several cases, implemented with lower space overhead. We also develop parallel product surgery for lifted clustered cyclic codes. Finally, we propose lifting as a systematic first step toward defining thermodynamic families for algebraically defined qLDPC codes without an underlying Euclidean lattice. For several base codes and selected lifts, coherent information exhibits finite-size crossings, while our results also indicate that additional conditions are needed to determine a unique family.

quant-pharXiv:2607.28621•Jul 31, 2026•7 citations

Logical computation with canonical lifted product codes

Han Zheng, Guo Zheng, Liang Jiang +1 more

High-rate quantum low-density parity-check (qLDPC) codes encode many logical qubits with low physical-qubit overhead, but realizing efficient fault-tolerant computation on such dense encodings remains a major challenge. Generic, code-agnostic techniques such as code surgery and gate teleportation apply broadly, but are difficult to make modular, low-overhead, and fully certifiable on complex high-rate codes whose structure is left unexploited. Here we overcome these obstacles by co-designing the code together with its logical instruction set for a broad family of canonical lifted-product (LP) codes with cyclic symmetry. We show that these codes admit a canonical logical basis, in which conjugate logical operators are organized into rows and columns of cyclic orbits inherited directly from the underlying classical codes, analogous to the structure that makes hypergraph-product codes so tractable. This canonical basis enables universal logical processing using magic-state input and a constant number of reusable seed surgery gadgets---only two (resp. four) for a $[[1122,148,\leq 20]]$ (resp. $[[4350,1224,\leq 20]]$) LP code. A fixed extractor smaller than half the data block also enables arbitrarily high-weight logical Pauli-product measurements (PPMs) while preserving the code's cyclic symmetry. These codes also enable rigorously fault-tolerant parallel logic, including PPMs across all logical qubits and magic-state injection from many surface codes into a full LP block. For example, a $[[468,36,20]]$ (resp. $[[952,112,17]]$) code supports simultaneous measurements of arbitrary logically disjoint Pauli products with an ancilla overhead of roughly three (resp. four) times the data block size. These results advance the frontier of fault-tolerant quantum computation on ultra-high-rate quantum architectures.

quant-pharXiv:2607.28605•Jul 31, 2026•16 citations

Error-detected surgery on Iceberg codes

Andrea Di Fini, Samuel Crew, Laura Pecorari +1 more

We construct explicit error-detecting surgery gadgets---small systems of auxiliary qubits and checks---for the high-rate Iceberg codes $[[2N,2N-2,2]]$, to perform fault-detected measurements of logical Pauli products. The construction follows the perspective of surgery as the gauging of a logical operator, regarded as a symmetry of the code. We give a complete classification of logical Pauli operators under the permutation automorphism group of the Iceberg code, reducing the construction to one gadget per orbit, and we verify with circuit-level simulations that the gadgets are fault-detecting, with the expected post-selected logical error rate. The gadgets require reconfigurable long-range connectivity, available on platforms such as neutral-atom arrays, making an error-detected demonstration of Pauli-based computation a natural near-term experiment. The paper doubles as a self-contained introduction to gauging and code surgery, developed alongside a simple worked example.

quant-pharXiv:2608.06187•Aug 7, 2026•2 citations
Code surgery measures a logical operator of a quantum LDPC code with O(d)O(d)O(d) rounds of syndrome extraction. Lifted surgery amortises this cost on Abelian group-algebra codes by measuring an orbit of logical operators under a translation symmetry in one merged code. We extend it to two-block group-algebra codes over non-Abelian groups and ask whether non-commutativity lets one merged code measure more operators than any Abelian group of its symmetries. We classify the block-affine automorphisms of these codes and find that, measured against this full group, most apparent non-Abelian gains disappear. We prove that the gain is at most the index of a largest Abelian subgroup. We find codes with exact distance up to 131313 where the gain is two, including codes in which one merged code reads out every logical qubit, and codes over products of A4A_4A4​, S4S_4S4​ and SL(2,3) with gain three for a best logical, up to [[336,26,12]][[336,26,12]][[336,26,12]]. A merged-distance lemma gives a simple condition for the gadget to preserve the code distance. In circuit-level simulations with Relay-BP decoding, at the error rates we can resolve, the non-Abelian gadget is as reliable as, or more reliable than, the Abelian gadgets it replaces within statistical error, while using two to three times fewer rounds.
Can non-Abelian symmetries increase the number of logical operators measured in one lifted-surgery gadget beyond what Abelian symmetries allow? This paper extends lifted surgery to non-Abelian two-block group-algebra codes, comparing disjoint, logically independent translates of a chosen logical under the full block-affine automorphism group EEE with those under its Abelian subgroups.
It classifies Tanner-level block-affine automorphisms under a support-stabiliser hypothesis and develops rigidity criteria. Twisted translations and outer automorphisms eliminate many apparent advantages over translation-only baselines. The remaining gain satisfies γ(v)≤min⁡H≤E AbeliancH(v)≤[E:Hmax⁡]\gamma(v)\le\min_{H\le E\text{ Abelian}}c_H(v)\le[E:H_{\max}]γ(v)≤minH≤E Abelian​cH​(v)≤[E:Hmax​], where cH(v)c_H(v)cH​(v) counts distinct translates of the Abelian orbit. Exhaustive automorphism searches, exact co-measurability optimisation and distance certification establish gain two in eleven codes with distances 666–131313; four permit simultaneous readout of every logical qubit. Sixteen further codes have best-logical gain at least three, including [[336,26,12]][[336,26,12]][[336,26,12]] and one gain of 10/310/310/3.
A merged-distance lemma preserves both CSS distances when each ancilla graph has Cheeger constant at least one. Circuit-level depolarising-noise simulations with Relay-BP decoding find two-to-threefold reductions in merged rounds relative to the selected Abelian gadgets, without statistically resolved reliability loss at the tested error rates.
The comparison excludes automorphisms outside the block-affine class and unrestricted symmetry-free parallel surgery. Gains depend on the chosen logical; some code-level comparisons cover only logical orbits found. Simulations probe measured ZZZ outcomes near pseudo-thresholds, not unmeasured-qubit damage or full fault distance. Higher-distance persistence, lower-error performance and operational benefits of symmetry-adapted ancillas remain open.
Quantum low-density parity-check (QLDPC) codes are a leading candidate for achieving low-overhead fault-tolerant quantum computing. However, the time overhead of logical operations in QLDPC codes remains a key challenge. Code surgery, a space-efficient technique for fault-tolerant logical measurements, incurs this overhead through repeated rounds of syndrome measurement. We introduce lifted surgery, a method for fast and parallel surgery on Abelian group algebra codes that maintains the low physical overhead that makes QLDPC codes attractive. Lifted surgery preserves the symmetries of the underlying code, making searches for large instances tractable and offering a natural route towards efficient hardware implementations. We utilise block decompositions and techniques from commutative algebra to characterise lifted surgery, investigate well-behaved subfamilies, and construct explicit examples. In particular, we present quantum radial codes with parameters [[90,8,10]][[90, 8, 10]][[90,8,10]] and [[198,8,16]][[198, 8, 16 ]][[198,8,16]] for which surgery is fast, parallel, and addressable, allowing arbitrary sets of independent logical operators of the same Pauli type to be measured in a single round of syndrome extraction. We benchmark lifted surgery under circuit-level depolarising noise and, for the [[90,8,10]][[ 90, 8, 10 ]][[90,8,10]] code, find logical performance comparable to standard code surgery while requiring ten times fewer rounds of syndrome measurement. By combining speed and parallelism, lifted surgery offers a practical route towards low-overhead fault-tolerant quantum computing.
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 10810^8108 two-block codes with up to 320320320 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≤200n \le 200n≤200 to reach kd2/n=12kd^2/n=12kd2/n=12, no weight-six two-block code with n≤300n \le 300n≤300 beats [[288,16,16]][[288,16,16]][[288,16,16]], and the known [[64,18,8]][[64,18,8]][[64,18,8]] is the best two-block code by kd2/nkd^2/nkd2/n across weights five to nine with n≤94n \le 94n≤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 nnn and non-abelian groups at large nnn, with the crossover appearing to move out as the check weight grows; and high quality codes become 100100100 to 100010001000 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]][[102,20,10]][[102,20,10]] and [[120,24,10]][[120,24,10]][[120,24,10]] at check weight nine, which we simulate in noisy syndrome-extraction circuits, and [[186,20,18]][[186,20,18]][[186,20,18]], a weight-nine code with every check in a 5×55\times55×5 window. At check weights seven to nine, our best codes exceed the best published kd2/nkd^2/nkd2/n with exact distance at the same check weight in most length bands up to 320320320 qubits. All codes are available in a public database.
Quantum LDPC memories can encode many logical qubits, but that alone does not make them usable: applications need to know where the logical operators are supported, how they are labeled, and how conjugate X/ZX/ZX/Z partners pair. For hypergraph-product codes this information follows from row reduction over F2\mathbb{F}_2F2​. For Abelian lifted-product codes, which include prominent high-rate constructions, it does not: the entries of the defining seed matrices live in a group algebra rather than a field, so pivots need not be invertible and row reduction can fail. To address this problem, we introduce \emph{logical spectroscopy}. For an odd-order Abelian lift group, the Chinese remainder theorem splits the group algebra into finite fields, one for each Frobenius orbit of characters; we call these orbits packets. Packet by packet, we solve ordinary finite-field linear algebra, lift the answers back to the physical code with the associated packet projectors, and pair XXX and ZZZ logicals between reciprocal packets by trace duality. The result is a complete conjugate logical basis for a finite Abelian lifted product code that is addressable: every logical coordinate carries canonical packet and Künneth-summand labels, deterministic within-block indices, a conjugate partner, and an explicit binary representative. The code's own translation symmetry then acts on these coordinates in closed form. We apply the construction to examples with up to 5000 physical qubits, including high-rate examples whose distance-witness is reported explicitly. We further extend the decomposition to even-order lifts. Logical spectroscopy thus equips Abelian lifted products with an explicit logical coordinate system and an algebraic toolkit for high-rate code search.
Lifted product (LP) codes form an important class of quantum error correcting codes with favorable code parameters. We introduce a systematic construction of LP code families based on group extensions and graph lifts. The construction increases the code size while preserving the local structure of the Tanner graph, and relates code parameters, logical operators, and fault-tolerant logical-operation gadgets within the families through chain and cochain maps. As a first application, we obtain LP codes with better code parameters than previously reported ones. We then demonstrate that code-surgery gadgets can be transferred across the selected finite lifts through chain maps and, in several cases, implemented with lower space overhead. We also develop parallel product surgery for lifted clustered cyclic codes. Finally, we propose lifting as a systematic first step toward defining thermodynamic families for algebraically defined qLDPC codes without an underlying Euclidean lattice. For several base codes and selected lifts, coherent information exhibits finite-size crossings, while our results also indicate that additional conditions are needed to determine a unique family.
High-rate quantum low-density parity-check (qLDPC) codes encode many logical qubits with low physical-qubit overhead, but realizing efficient fault-tolerant computation on such dense encodings remains a major challenge. Generic, code-agnostic techniques such as code surgery and gate teleportation apply broadly, but are difficult to make modular, low-overhead, and fully certifiable on complex high-rate codes whose structure is left unexploited. Here we overcome these obstacles by co-designing the code together with its logical instruction set for a broad family of canonical lifted-product (LP) codes with cyclic symmetry. We show that these codes admit a canonical logical basis, in which conjugate logical operators are organized into rows and columns of cyclic orbits inherited directly from the underlying classical codes, analogous to the structure that makes hypergraph-product codes so tractable. This canonical basis enables universal logical processing using magic-state input and a constant number of reusable seed surgery gadgets---only two (resp. four) for a [[1122,148,≤20]][[1122,148,\leq 20]][[1122,148,≤20]] (resp. [[4350,1224,≤20]][[4350,1224,\leq 20]][[4350,1224,≤20]]) LP code. A fixed extractor smaller than half the data block also enables arbitrarily high-weight logical Pauli-product measurements (PPMs) while preserving the code's cyclic symmetry. These codes also enable rigorously fault-tolerant parallel logic, including PPMs across all logical qubits and magic-state injection from many surface codes into a full LP block. For example, a [[468,36,20]][[468,36,20]][[468,36,20]] (resp. [[952,112,17]][[952,112,17]][[952,112,17]]) code supports simultaneous measurements of arbitrary logically disjoint Pauli products with an ancilla overhead of roughly three (resp. four) times the data block size. These results advance the frontier of fault-tolerant quantum computation on ultra-high-rate quantum architectures.
We construct explicit error-detecting surgery gadgets---small systems of auxiliary qubits and checks---for the high-rate Iceberg codes [[2N,2N−2,2]][[2N,2N-2,2]][[2N,2N−2,2]], to perform fault-detected measurements of logical Pauli products. The construction follows the perspective of surgery as the gauging of a logical operator, regarded as a symmetry of the code. We give a complete classification of logical Pauli operators under the permutation automorphism group of the Iceberg code, reducing the construction to one gadget per orbit, and we verify with circuit-level simulations that the gadgets are fault-detecting, with the expected post-selected logical error rate. The gadgets require reconfigurable long-range connectivity, available on platforms such as neutral-atom arrays, making an error-detected demonstration of Pauli-based computation a natural near-term experiment. The paper doubles as a self-contained introduction to gauging and code surgery, developed alongside a simple worked example.