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.
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(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 m generator rows on n qubits, the bounds are O(mn2+n4) binary operations and O(mn+n3) bits of storage; independent inputs require 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 X/Z checks. Conversion preserves n,k,d; sparse input checks of weight at most w and incidence at most Δ yield at most twice as many checks, with weight at most w and incidence at most 2Δ.
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 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†; (b) show that the condition C2∗C1⊆C1⊥ 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.
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 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 XYZ2 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 n labelled vertices in 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) 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 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 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.