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.28737

Local Clifford equivalence to CSS codes: Polynomial-time classification and conversion

Mingyuan Wang, Stefan Krastanov

quant-phSubmitted Oct 20, 2026• Announced Oct 22, 2026• 0 citations
arXivHTMLPDF

Abstract

Calderbank--Shor--Steane (CSS) codes support decoding and fault-tolerant logical operations through separate pure $X$ and pure $Z$ stabilizer checks. Generator choices and single-qubit Clifford transformations can obscure this structure. We give a deterministic polynomial-time algorithm that decides whether an arbitrary stabilizer code is locally Clifford-equivalent to a CSS code and constructs the required transformation and CSS checks whenever such a form exists. For $m$ possibly redundant generator rows on $n$ qubits, the algorithm uses $O(mn^2+n^4)$ binary field operations. We reduce the problem to affine linear systems by characterizing local projectors that preserve the span of the binary stabilizer labels. The conversion preserves code parameters and check sparsity for quantum low-density parity-check (qLDPC) codes. We demonstrate CSS recovery and decoder reuse and resolve previously open LC-to-CSS classification questions for published code constructions. For graph states, LC-to-CSS equivalence corresponds to the existence of a bipartite graph in the local-complementation orbit. We derive a necessary-and-sufficient adjacency-matrix criterion for this property and construct such a graph whenever one exists. Our algorithm makes CSS decoding and fault-tolerant constructions accessible throughout the local Clifford equivalence classes of CSS codes.

AI Summary

The paper asks whether an arbitrary stabilizer code is locally Clifford-equivalent to a CSS code, with the target CSS representation unspecified. It gives a deterministic decision-and-conversion algorithm accepting redundant generators and any number of logical qubits. For $m$ generator rows on $n$ qubits, the bounds are $O(mn^2+n^4)$ binary operations and $O(mn+n^3)$ bits of storage; independent inputs require $O(n^4)$ time. The method characterizes CSS equivalence through block-diagonal, rank-one projectors preserving the stabilizer label space. After decomposition over disjoint qubit sets, preservation is affine-linear, and idempotence reduces to two affine branches per component. Acceptance produces single-qubit Clifford maps and pure $X$/$Z$ checks. Conversion preserves $n,k,d$; sparse input checks of weight at most $w$ and incidence at most $\Delta$ yield at most twice as many checks, with weight at most $w$ and incidence at most $2\Delta$. Applications give a support-preserving CSS conversion for every odd-distance XYZ-2D code, exclude the 512-qubit XYZ-IS instance and all 12 published XYZ cyclic instances, and classify 357 previously unresolved perturbed bicycle entries as negative. Of 191 halved pair-partition entries, only one is CSS-equivalent. Computational classifications use exact binary verification. For graph states, an adjacency-matrix criterion decides whether the local-complementation orbit contains a bipartite graph and constructs one. The classification concerns local Clifford transformations, not general local unitaries. Decoder transfer is formulated for Pauli noise and exact syndromes; validation uses Clifford-deformed bicycle codes rather than circuit-level noisy syndrome extraction.

No sign of AI-generated textAI use disclosed
A separately developed verifier, also created with AI assistance, uses exact arithmetic over $\F$ to check the classifications from the original stabilizer check matrices.

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

Comments
16 pages

Related papers

Asymptotically good CSS codes that realize the logical transversal Clifford group fault-tolerantly

K. Sai Mineesh Reddy, Navin Kashyap

This paper introduces a framework for constructing Calderbank-Shor-Steane (CSS) codes that support fault-tolerant logical transversal $Z$-rotations. Using this framework, we obtain asymptotically good CSS codes that fault-tolerantly realize the logical transversal Clifford group (i.e., transversal single-qubit Clifford gates are realized within a single code block, while transversal two-qubit Clifford gates are realized across two identical code blocks). Furthermore, investigating CSS-T codes, we: (a) demonstrate asymptotically good CSS-T codes wherein the transversal $T$ realizes the logical transversal $S^{\dagger}$; (b) show that the condition $C_2 \ast C_1 \subseteq C_1^{\perp}$ is necessary but not sufficient for CSS-T codes; and (c) revise the characterizations of CSS-T codes wherein the transversal $T$ implements the logical identity and the logical transversal $T$, respectively.

quant-pharXiv:2601.08568•IEEE International Symposium on Information Theory (ISIT)•Jan 14, 2026•5 citations

Beyond transversality: structure of Clifford circuits for CSS codes

Victor V. Albert

We characterize four groups of Clifford circuits for Calderbank--Shor--Steane (CSS) codes that are relevant to fault-tolerant logical operations. First, we show that every code-preserving Clifford circuit is a product of Z-diagonal circuits, composed of S and CZ gates, and their X-basis analogues. Second, we define the two-fold transversal group, generated by depth-one two-local code-preserving circuits, and show that each of its elements can be expressed as a product of layers consisting of either Z-diagonal, X-diagonal, or CNOT gates. As a corollary, every transversal gate is a product of three transversal diagonal circuits; for connected non-self-dual codes, two such circuits suffice. We further show that every code-preserving automorphism circuit, consisting of single-qubit Clifford gates and permutations, has a normal form comprising a Hadamard layer, a permutation, and two diagonal circuits. We also define a two-fold automorphism group, in which a depth-one two-local circuit may be code-preserving up to a permutation, and show that its logical image can be larger than that of the two-fold transversal group. For 231 CSS codes, we provide explicit generators and determine the logical image of the two-fold transversal group. We tabulate 173 codes whose full logical Clifford group is generated by two-fold-transversal circuits, including codes of distances 3, 4, 5, 6, 8, 10, 12, and 13, with respective best rates 2/5, 3/4, 34/77, 17/28, 14/25, 1/27, 3/56, and 1/33. We construct families of CSS codes from bipartite grids, cut-complements, and quadrics, and census the self-dual codes invariant under rank-3 permutation groups. Many of these codes realize the full logical Clifford group in this way.

quant-pharXiv:2608.05688•Aug 7, 2026•8 citations

Quantum XYZ Stabilizer Codes

Alessio Baldelli, Davide Orsucci, Francisco Lázaro +1 more

Stabilizer codes are often constructed within the Calderbank--Shor--Steane (CSS) framework, where two mutually orthogonal binary classical codes define $X$ and $Z$-type stabilizer generators. While this structure is algebraically convenient, additional non-CSS constraints may help suppress low-weight logical operators and improve decoding performance in the finite-length regime. We thus introduce quantum XYZ stabilizer codes, whose parity-check matrix (PCM) is built from three pairwise orthogonal binary PCMs associated with $X$-, $Y$-, and $Z$-type stabilizer generators. A nontrivial point is that an XYZ code instance is not automatically genuinely non-CSS: the same stabilizer group may admit a CSS generating set. We characterize this collapse, obtaining algebraic and rank conditions for deciding when the $Y$-type checks are redundant and when they define genuinely non-CSS stabilizer constraints. We also derive upper and lower bounds on the quantum minimum distance, including bounds for mixed Pauli logical operators. The novel framework includes a known non-CSS topological code, namely the XYZ$^2$ hexagonal code, and yields also sparse finite-length quantum low-density parity-check (qLDPC) constructions from intersecting-subset and quasi-dyadic code families. Simulations under depolarizing code-capacity noise and quaternary belief propagation decoding show that the proposed XYZ qLDPC instances can outperform representative CSS qLDPC instances with similar finite-length parameters.

cs.ITCross-listedarXiv:2607.14988•Jul 17, 2026•1 citation

Efficient Quantum Stabilizer Codes: LDPC and LDPC-Convolutional Constructions

Peiyu Tan, Jing Li

Existing quantum stabilizer codes constructed from the classic binary codes exclusively belong to the special subclass of Calderbank-Shor-Steane (CSS) codes. This paper fills in the gap by proposing five systematic constructions for non-CSS stabilizer codes, the first four of which are based on classic binary quasi-cyclic low-density parity-check (LDPC) codes and last on classic binary LDPC-convolutional codes. These new constructions exploit structured sparse graphs, make essential use of simple and powerful coding techniques including concatenation, rotation and scrambling, and generate rich classes of codes with a wide range of lengths and rates. We derive the sufficient, and in some cases also the necessary, conditions for each construction to satisfy the general symplectic inner product (SIP) condition, and develop practical decoder algorithms for these codes. The resulting codes are the first classes of non-CSS quantum LDPC codes and non-CSS quantum convolutional codes rooted from classic binary codes (rather than codes in GF(4)), and some of them perform as well as or better than the existing quantum codes.

IEEE Transactions on Information Theory•Jan 1, 2010•50 citations

Polynomial-time local-unitary equivalence of graph states

Yuxuan Zhang

Local-unitary (LU) equivalence asks whether two quantum states differ only by independent changes of basis on their qubits. For graph states, whether this relation can be decided in polynomial time has remained open for over a decade. We give a deterministic algorithm that decides LU equivalence for graphs on $n$ labelled vertices in $\widetilde O(n^{6.38})$ bit operations and constructs exact single-qubit unitaries whenever the states are equivalent. Building on Claudet and Perdrix's quasipolynomial algorithm, we replace the enumeration of vertex subsets by a compact system of constraints generated from pairs and triples. The remaining graph transformation is found by solving linear equations over the binary field. These new steps cost $\widetilde O(n^5)$ bit operations; the inherited graph preprocessing sets the overall bound. We also count the local-Clifford (LC) classes of graph states within any LU class: their number is a power of two, computable within the same bound. For any given graph state, this decides whether single-qubit Clifford gates reach every graph state in its LU class, and supplies a counterexample when they do not. The method also decides LU equivalence of stabilizer codes encoding one logical qubit.

quant-pharXiv:2610.00527•Oct 2, 2026•0 citations

Toric codes all the way down: decoupling translation-invariant topological CSS codes in higher dimensions

Mingxin He, Yifei Wang, Hao Song +1 more

Topological Calderbank-Shor-Steane (CSS) codes in more than two spatial dimensions offer features useful for fault-tolerant quantum computation, such as transversal non-Clifford gates and single-shot decoding, but a systematic understanding of them is still lacking. One approach is to decouple a code: map it to a stack of higher-form toric codes by a finite-depth local CSS-preserving Clifford circuit, possibly after adding ancillas. For translation-invariant $p$-ary CSS codes, where $p$ is prime ($p=2$ for qubits), we require the circuit to commute with the translations of a superlattice. In two dimensions, such a decoupling exists once these translations act trivially on every anyon type. In higher dimensions, excitations are sorted by their dimension into superselection layers, which can remain glued together even when translations act trivially on each layer. We show that this gluing is the only remaining obstruction: a code can be decoupled on a superlattice exactly when, after coarse-graining to it, translations act trivially on every layer and the gluing vanishes. Moreover, for a code with finitely many excitation types in each layer and $m$ nonzero layers, once translations act trivially on every layer, further coarse-graining by a factor of $p^{m-1}$ in every direction removes the aforementioned gluing. Physically, the same criterion determines when the code encodes the maximal number of logical qudits on a finite torus. Finally, we give an explicit algorithm that constructs the decoupling as a circuit of SUM (qudit CNOT) and SWAP gates.

quant-pharXiv:2610.40592•Oct 30, 2026•0 citations
Calderbank--Shor--Steane (CSS) codes support decoding and fault-tolerant logical operations through separate pure XXX and pure ZZZ stabilizer checks. Generator choices and single-qubit Clifford transformations can obscure this structure. We give a deterministic polynomial-time algorithm that decides whether an arbitrary stabilizer code is locally Clifford-equivalent to a CSS code and constructs the required transformation and CSS checks whenever such a form exists. For mmm possibly redundant generator rows on nnn qubits, the algorithm uses O(mn2+n4)O(mn^2+n^4)O(mn2+n4) binary field operations. We reduce the problem to affine linear systems by characterizing local projectors that preserve the span of the binary stabilizer labels. The conversion preserves code parameters and check sparsity for quantum low-density parity-check (qLDPC) codes. We demonstrate CSS recovery and decoder reuse and resolve previously open LC-to-CSS classification questions for published code constructions. For graph states, LC-to-CSS equivalence corresponds to the existence of a bipartite graph in the local-complementation orbit. We derive a necessary-and-sufficient adjacency-matrix criterion for this property and construct such a graph whenever one exists. Our algorithm makes CSS decoding and fault-tolerant constructions accessible throughout the local Clifford equivalence classes of CSS codes.
The paper asks whether an arbitrary stabilizer code is locally Clifford-equivalent to a CSS code, with the target CSS representation unspecified. It gives a deterministic decision-and-conversion algorithm accepting redundant generators and any number of logical qubits. For mmm generator rows on nnn qubits, the bounds are O(mn2+n4)O(mn^2+n^4)O(mn2+n4) binary operations and O(mn+n3)O(mn+n^3)O(mn+n3) bits of storage; independent inputs require O(n4)O(n^4)O(n4) time.
The method characterizes CSS equivalence through block-diagonal, rank-one projectors preserving the stabilizer label space. After decomposition over disjoint qubit sets, preservation is affine-linear, and idempotence reduces to two affine branches per component. Acceptance produces single-qubit Clifford maps and pure XXX/ZZZ checks. Conversion preserves n,k,dn,k,dn,k,d; sparse input checks of weight at most www and incidence at most Δ\DeltaΔ yield at most twice as many checks, with weight at most www and incidence at most 2Δ2\Delta2Δ.
Applications give a support-preserving CSS conversion for every odd-distance XYZ-2D code, exclude the 512-qubit XYZ-IS instance and all 12 published XYZ cyclic instances, and classify 357 previously unresolved perturbed bicycle entries as negative. Of 191 halved pair-partition entries, only one is CSS-equivalent. Computational classifications use exact binary verification. For graph states, an adjacency-matrix criterion decides whether the local-complementation orbit contains a bipartite graph and constructs one.
The classification concerns local Clifford transformations, not general local unitaries. Decoder transfer is formulated for Pauli noise and exact syndromes; validation uses Clifford-deformed bicycle codes rather than circuit-level noisy syndrome extraction.
This paper introduces a framework for constructing Calderbank-Shor-Steane (CSS) codes that support fault-tolerant logical transversal ZZZ-rotations. Using this framework, we obtain asymptotically good CSS codes that fault-tolerantly realize the logical transversal Clifford group (i.e., transversal single-qubit Clifford gates are realized within a single code block, while transversal two-qubit Clifford gates are realized across two identical code blocks). Furthermore, investigating CSS-T codes, we: (a) demonstrate asymptotically good CSS-T codes wherein the transversal TTT realizes the logical transversal S†S^{\dagger}S†; (b) show that the condition C2∗C1⊆C1⊥C_2 \ast C_1 \subseteq C_1^{\perp}C2​∗C1​⊆C1⊥​ is necessary but not sufficient for CSS-T codes; and (c) revise the characterizations of CSS-T codes wherein the transversal TTT implements the logical identity and the logical transversal TTT, respectively.
We characterize four groups of Clifford circuits for Calderbank--Shor--Steane (CSS) codes that are relevant to fault-tolerant logical operations. First, we show that every code-preserving Clifford circuit is a product of Z-diagonal circuits, composed of S and CZ gates, and their X-basis analogues. Second, we define the two-fold transversal group, generated by depth-one two-local code-preserving circuits, and show that each of its elements can be expressed as a product of layers consisting of either Z-diagonal, X-diagonal, or CNOT gates. As a corollary, every transversal gate is a product of three transversal diagonal circuits; for connected non-self-dual codes, two such circuits suffice. We further show that every code-preserving automorphism circuit, consisting of single-qubit Clifford gates and permutations, has a normal form comprising a Hadamard layer, a permutation, and two diagonal circuits. We also define a two-fold automorphism group, in which a depth-one two-local circuit may be code-preserving up to a permutation, and show that its logical image can be larger than that of the two-fold transversal group. For 231 CSS codes, we provide explicit generators and determine the logical image of the two-fold transversal group. We tabulate 173 codes whose full logical Clifford group is generated by two-fold-transversal circuits, including codes of distances 3, 4, 5, 6, 8, 10, 12, and 13, with respective best rates 2/5, 3/4, 34/77, 17/28, 14/25, 1/27, 3/56, and 1/33. We construct families of CSS codes from bipartite grids, cut-complements, and quadrics, and census the self-dual codes invariant under rank-3 permutation groups. Many of these codes realize the full logical Clifford group in this way.
Stabilizer codes are often constructed within the Calderbank--Shor--Steane (CSS) framework, where two mutually orthogonal binary classical codes define XXX and ZZZ-type stabilizer generators. While this structure is algebraically convenient, additional non-CSS constraints may help suppress low-weight logical operators and improve decoding performance in the finite-length regime. We thus introduce quantum XYZ stabilizer codes, whose parity-check matrix (PCM) is built from three pairwise orthogonal binary PCMs associated with XXX-, YYY-, and ZZZ-type stabilizer generators. A nontrivial point is that an XYZ code instance is not automatically genuinely non-CSS: the same stabilizer group may admit a CSS generating set. We characterize this collapse, obtaining algebraic and rank conditions for deciding when the YYY-type checks are redundant and when they define genuinely non-CSS stabilizer constraints. We also derive upper and lower bounds on the quantum minimum distance, including bounds for mixed Pauli logical operators. The novel framework includes a known non-CSS topological code, namely the XYZ2^22 hexagonal code, and yields also sparse finite-length quantum low-density parity-check (qLDPC) constructions from intersecting-subset and quasi-dyadic code families. Simulations under depolarizing code-capacity noise and quaternary belief propagation decoding show that the proposed XYZ qLDPC instances can outperform representative CSS qLDPC instances with similar finite-length parameters.
Existing quantum stabilizer codes constructed from the classic binary codes exclusively belong to the special subclass of Calderbank-Shor-Steane (CSS) codes. This paper fills in the gap by proposing five systematic constructions for non-CSS stabilizer codes, the first four of which are based on classic binary quasi-cyclic low-density parity-check (LDPC) codes and last on classic binary LDPC-convolutional codes. These new constructions exploit structured sparse graphs, make essential use of simple and powerful coding techniques including concatenation, rotation and scrambling, and generate rich classes of codes with a wide range of lengths and rates. We derive the sufficient, and in some cases also the necessary, conditions for each construction to satisfy the general symplectic inner product (SIP) condition, and develop practical decoder algorithms for these codes. The resulting codes are the first classes of non-CSS quantum LDPC codes and non-CSS quantum convolutional codes rooted from classic binary codes (rather than codes in GF(4)), and some of them perform as well as or better than the existing quantum codes.
Local-unitary (LU) equivalence asks whether two quantum states differ only by independent changes of basis on their qubits. For graph states, whether this relation can be decided in polynomial time has remained open for over a decade. We give a deterministic algorithm that decides LU equivalence for graphs on nnn labelled vertices in O~(n6.38)\widetilde O(n^{6.38})O(n6.38) bit operations and constructs exact single-qubit unitaries whenever the states are equivalent. Building on Claudet and Perdrix's quasipolynomial algorithm, we replace the enumeration of vertex subsets by a compact system of constraints generated from pairs and triples. The remaining graph transformation is found by solving linear equations over the binary field. These new steps cost O~(n5)\widetilde O(n^5)O(n5) bit operations; the inherited graph preprocessing sets the overall bound. We also count the local-Clifford (LC) classes of graph states within any LU class: their number is a power of two, computable within the same bound. For any given graph state, this decides whether single-qubit Clifford gates reach every graph state in its LU class, and supplies a counterexample when they do not. The method also decides LU equivalence of stabilizer codes encoding one logical qubit.
Topological Calderbank-Shor-Steane (CSS) codes in more than two spatial dimensions offer features useful for fault-tolerant quantum computation, such as transversal non-Clifford gates and single-shot decoding, but a systematic understanding of them is still lacking. One approach is to decouple a code: map it to a stack of higher-form toric codes by a finite-depth local CSS-preserving Clifford circuit, possibly after adding ancillas. For translation-invariant ppp-ary CSS codes, where ppp is prime (p=2p=2p=2 for qubits), we require the circuit to commute with the translations of a superlattice. In two dimensions, such a decoupling exists once these translations act trivially on every anyon type. In higher dimensions, excitations are sorted by their dimension into superselection layers, which can remain glued together even when translations act trivially on each layer. We show that this gluing is the only remaining obstruction: a code can be decoupled on a superlattice exactly when, after coarse-graining to it, translations act trivially on every layer and the gluing vanishes. Moreover, for a code with finitely many excitation types in each layer and mmm nonzero layers, once translations act trivially on every layer, further coarse-graining by a factor of pm−1p^{m-1}pm−1 in every direction removes the aforementioned gluing. Physically, the same criterion determines when the code encodes the maximal number of logical qudits on a finite torus. Finally, we give an explicit algorithm that constructs the decoupling as a circuit of SUM (qudit CNOT) and SWAP gates.