Shift Automorphisms in qLDPC Codes

• The paper demonstrates that shift automorphisms enable efficient, fault-tolerant logical gate operations in qLDPC codes without requiring code deformation.
• It leverages algebraic foundations in quasi-cyclic and toric constructions to create block-circulant parity-check matrices essential for optimized decoding.
• Dynamic shift circuits merge syndrome extraction with qubit translations, significantly reducing logical error rates compared to traditional SWAP-based approaches.

Shift automorphisms in quantum low-density parity-check (qLDPC) codes are global, fault-tolerant permutations of physical qubits that implement nontrivial logical operations, including Clifford gates and arbitrary Pauli measurements, without the need for code deformation. These automorphisms, typically realized as cyclic or lattice translations of the code’s structure, underpin rapid, low-overhead logical gate implementations that are essential for scalable quantum error correction. Shift automorphisms are intimately tied to the algebraic and module-theoretic foundations of qLDPC codes, especially in constructions with quasi-cyclic or toric product structure, and exhibit deep connections to both classical LDPC design and quantum syndrome measurement circuit engineering.

1. Algebraic Foundations: Shift Automorphisms in qLDPC Codes

Shift automorphisms are induced by global permutations of code coordinates that respect the stabilizer code’s structure. In the context of generalized toric qLDPC codes and quasi-cyclic LDPC codes, these automorphisms are formalized as group actions, typically translations by powers of $x$ and $y$ in a polynomial ring modulo lattice periodicity, or equivalently, the cyclic group action by multiplication of $X^k$ in $R_\ell = \mathbb{F}_q[X]/(X^\ell-1)$ for codes of block length $\ell$ (Golowich et al., 2024, Bouyuklieva, 2023). The symmetry allows decomposition of codewords and checks into orbits and facilitates the design of generator and parity-check matrices as blocks of circulant submatrices. Algebraically, a shift of qubits indexed by $\delta \mapsto s\delta$ commutes with both the stabilizer group generators and the underlying code constraints (e.g., the X- and Z-check polynomials in toric codes), and implements a linear transformation on the logical basis:

$$|z\rangle \mapsto |A_z z\rangle, \quad |x\rangle \mapsto |A_x x\rangle$$

where $A_z, A_x$ are matrices describing logical action on each block (Kim et al., 14 Jan 2026).

2. Construction and Structural Properties in Quasi-Cyclic and Generalized Toric Codes

Shift automorphisms fundamentally characterize quasi-cyclic LDPC and generalized toric qLDPC codes. For a QC-LDPC code of length $N = nZ$, the automorphism group includes the cyclic subgroup $Q_Z$ generated by “column-shifts” $\pi_{d,Z}$, acting on both codeword and parity-check matrix coordinates (Geiselhart et al., 2022). These permutations cyclically relabel $Z$-blocks throughout the parity-check matrix, and are absorbed by the decoder unless the factor graph symmetry is actively broken. In the polynomial module language, codewords are structured as elements of $R^s$ (where $R = \mathbb{F}_q[x]/(x^m-1)$), and the shift operator $o$ of order $m$ decomposes the ambient space into $s$ cycles of length $m$ each, corresponding to quasi-cyclic constituent codes (Bouyuklieva, 2023). This cyclic invariance partitions qubits and checks into orbits, guarantees commutation with code operators, and leads to block-circulant structure in generator and parity-check matrices, enabling efficient encoding and decoding.

3. Fault-Tolerant Implementation: Syndromic and Circuit Approaches

Realizing shift automorphisms fault-tolerantly is a major challenge in practical qLDPC memory and computation. The traditional approach decomposes the shift into nearest-neighbor SWAP operations, each implemented as layers of three CNOT gates, interleaved among full syndrome extraction cycles (SECs). While correct in preserving the code space, this method induces deep circuits with high time and fault-location overhead, drastically inflating the number of possible error locations ($N_\text{SWAP}$) (Kim et al., 14 Jan 2026). For example, in the weight-6 “gross code” [[144,12,12]] at $p=10^{-3}$ physical error rate, SWAP-based shifts increase the fault locations from about $5\times10^5$ (idle) to $1.47\times10^6$, with logical error rates exceeding memory by roughly $35\times$.

Time-dynamic shift circuits provide a rigorous alternative. By analyzing the possible SEC variants—each corresponding to edge colorings of the Tanner graph—and choosing those whose initial or final CNOT layers align with the required qubit swaps, one can algebraically merge SWAP steps into SEC rounds without reducing circuit distance $d_\text{circ}$. This dynamic method executes a full shift (e.g., $s=x$) in two SECs plus one extra CNOT layer (19 timesteps, comparable to previous implementations but with dramatically lowered error rates and reduced fault locations). The coloration-search approach generalizes to twisted and untwisted toric codes, and preserves both code and circuit distance (Kim et al., 14 Jan 2026).

4. Decoding, Error Correction, and Benchmarks

Decoders for codes with shift automorphisms exploit the underlying symmetry to improve logical error rates and time overhead. Benchmarking in (Kim et al., 14 Jan 2026) employs the SI1000 circuit-level noise model and BP-OSD (Belief Propagation with Ordered Statistics Decoding), analyzing both gross and smaller toric codes as well as twisted generalizations. Results show that time-dynamic shift circuits achieve logical error rates nearly matching idle memory operations and reduce logical errors by more than an order of magnitude compared to SWAP-based implementations (e.g., $p_L^{X,\text{shift}} \approx 3.5 \times 10^{-3}$ versus $p_L^{X,\text{SWAP}} \approx 7 \times 10^{-2}$ for the gross code at $p=10^{-3}$, with a circuit distance of $d_\text{circ}=10$). Similar performance gains hold across twisted codes and for smaller block sizes.

In the classical QC and generalized QC context, automorphism-ensemble decoding (AED) leverages the list of distinct cyclic shifts, with symmetry-breaking at the receiver to ensure genuine diversity among decoding trajectories. This method yields consistent $0.2$–$0.3$ dB improvements over standard BP decoding with no extra latency (Geiselhart et al., 2022). The symmetry of the QC factor graph must be broken (via row addition, deletion, or overcomplete checks) or else shifts are absorbed, resulting in no gain. AED runs $Z$ BP decoders in parallel, each with a shifted parity-check matrix, and selects the output nearest to the channel observation in Euclidean metric.

5. Implications for Code Families, Circuit Design, and Leakage-Removal Protocols

The coloration-based shift circuit framework is broadly applicable across qLDPC code families that admit sufficient Tanner graph symmetry, including hypergraph product codes, bicycle codes, and CSS codes built from dual-containing quasi-cyclic LDPCs (Golowich et al., 2024, Bouyuklieva, 2023, Kim et al., 14 Jan 2026). Modules over $R_\ell$ (group algebra) yield $l$-shift symmetry, and boundary maps (e.g., those in lifted product constructions) inherit block-circulant structure, facilitating both logical operations and syndrome extraction.

Dynamic circuits for shift automorphisms unify fault-tolerant code operation and syndrome management, paralleling “leakage-removal” walking circuits in surface codes. Notably, even the trivial automorphism $s=1$ can be harnessed to perform periodic data qubit resets without degrading circuit distance, embedding leakage-mitigation protocols within the logical gate implementation scheme (Kim et al., 14 Jan 2026). Further, the merger of shift-circuit design with alternative syndrome extraction schedules—including hook-free, non-CZ-native, and ancilla-free protocols—suggests additional optimization avenues in connectivity and operational overhead. Decoder co-design (e.g., integrating relay-BP or localized statistics decoders tuned for shift circuits) is a plausible avenue for closing the small performance gap that remains between shift-induced and memory-only logical error rates.

6. Theoretical Structure of Codes with Shift Automorphisms

Linear codes over $\mathbb{F}_q$ with a permutation automorphism of order $m$ are characterized as $R$-submodules ($R=\mathbb{F}_q[x]/(x^m-1)$) of $R^s$, corresponding to generalized quasi-cyclic codes of length $sm$ (with $s$ orbits of size $m$) (Bouyuklieva, 2023). The idempotent decomposition of $R$ (via factorization of $x^m-1$) enables constituent-wise code analysis, facilitating the construction of LDPC codes with constant row and column weight. Self-orthogonality, self-duality, and LCD criteria hold in constituent form:

• Self-duality requires certain mutual orthogonality and duality properties among the code’s constituents (see Theorem 4.1 in (Bouyuklieva, 2023)).
• The block-circulant structure of parity-check matrices ensures fast encoding and decodability.
• Imposing self-orthogonality constituent-wise yields dual-containing codes suitable for CSS quantum error correction (Bouyuklieva, 2023).

This algebraic perspective elucidates why shift automorphisms are a universal resource for logical gates, efficient encoding, and fault-tolerant operations in both classical and quantum LDPC codes, and underscores their role in the ongoing advancement toward scalable quantum fault tolerance.

---

Table: Logical Error Rate and Overhead for SWAP-Based vs. Shift Circuits (Kim et al., 14 Jan 2026)

Code	Method	Logical Error Rate ($p=10^{-3}$)	Fault Locations ($N$)
[[144,12,12]]	Memory (idle)	$2\times 10^{-3}$	$\approx 4.75 \times 10^5$
[[144,12,12]]	SWAP-based	$7\times 10^{-2}$	$\approx 1.47 \times 10^6$
[[144,12,12]]	Shift circuit	$3.5\times 10^{-3}$	$\approx 4.96 \times 10^5$

This table summarizes the dramatic reduction in logical error rate and fault locations when using time-dynamic shift circuits compared to the traditional SWAP-based approach for the gross code [[144,12,12]].