Universal graph representation of stabilizer codes

TL;DR

This work introduces a universal graph representation for all stabilizer codes by mapping stabilizer tableaus to encoder-respecting graphs through ZX-calculus and ZX canonical forms, establishing a bijection up to encoder equivalence. The authors prove a four-rule ZXCF framework that canonically encodes encoders into simple graphs, enabling efficient graph-based compilation in O("n^3") and inverse mapping in O("n^2"). They show that code properties such as distance and stabilizer weight are controlled by graph degree, and encode/decode operations can be understood as quantum-lights-out games, yielding a greedy decoder with provable guarantees for broad classes of graphs (e.g., girth > 12). The framework yields concrete code families with favorable distance-rate characteristics, a dodecahedral and icosahedral-based construction, and a random-graph GV-type bound with reduced stabilizer weights, illustrating practical graph-guided code design. Overall, the graph formalism offers a versatile, constructive toolkit for universal stabilizer-code design, analysis, and decoding that complements CSS/qLDPC approaches and holds promise for device-tailored quantum error correction.

Abstract

While stabilizer tableaus have proven useful as a descriptive tool for additive quantum codes, they otherwise offer little guidance for concrete constructions or algorithm analysis. We introduce a representation of stabilizer codes as graphs with certain structures, and prove via the ZX Calculus that this representation is related to stabilizer tableaus by an efficiently computable bijection. This gives a new universal recipe for code construction by way of finding graphs with nice properties. The graph representation gives insight into both code construction and algorithms. We construct as examples families of $[[ n, \;Θ(\frac{n}{\log n}), \;Θ(\log n)]]$ and $[[ n, \;Ω(n^{4/5}), \;Θ(n^{1/5}) ]]$ codes. We use graphs in a probabilistic analysis to extend the quantum Gilbert-Varshamov bound into a three-way distance-rate-weight trade-off. Moreover, code properties such as distance and encoding circuit depth are bounded by simple functions of the graph degree. We prove that key coding algorithms -- distance approximation, minimum weight generator selection, and decoding -- are unified as instances of one optimization game on a graph. By studying this game, we construct an efficient greedy decoder and prove that it corrects all recoverable errors for all graphs with cycle lengths no shorter than 13 (reducible to 5 with mild extra constraints); these include the above two families. Our results suggest that graphs are generically useful for the study of stabilizer codes.

Figures (28)

• Figure 1: Example of an encoder-respecting form and some ways it might violate the 4 rules. Recall that dotted blue edges indicate the presence of a Hadamard on that edge. Rule 1, the Edge Rule, is violated in two places: one of the internal edges does not contain a Hadamard gate and a $Z$ does not have exactly one free edge. Rule 2, the Hadamard Rule, is violated where the second output node has a Hadamard on its free edge, but since the node is connected to the lower-numbered first output node, this is not acceptable. Rule 3, the RREF Rule, is violated where $M_{\mathcal{E}}$ is not in reduced row-echelon form, as we see that the first input is connected to the first output, meaning no other inputs should be connected to that first output node. Rule 4, the Clifford Rule, is violated twice: one in having a local Clifford operation, $S$, on an input node, and where an $H$ is placed on the first output node, which is a node associated with a pivot column of $M_{\mathcal{E}}$.
• Figure 2: Illustration of the compilation process of a $\llbracket 4, 2, 2 \rrbracket$ code with stabilizers $XXXX$ and $ZZZZ$. In (a), we begin with the encoding circuit of the code. We then map it into the ZX calculus in (b), where yellow boxes (as well as dotted blue edges) represent Hadamards $H$, and the green and red nodes are the standard notation in the ZX calculus. In (c), we turn the circuit into a state by moving input wires to output wires. (d) implements the transformation from hu2022improved, turning it into a canonical form which satisfies the Edge and Hadamard rules. We then return the state to a circuit in (e) by moving the output wires from (c) back to input wires. To satisfy the RREF rule, we apply gates on inputs and the bialgebra rule---an equivalence transformation in the ZX calculus---in (f) and (g). The details of these simplification steps are all discussed in Appendix \ref{['app:sec:compiler']}. Finally, in (h) and (i) we simplify and remove free edges to turn the diagram into a graph. In the final graph, the inputs are blue (leftmost column) and the outputs are black (middle and right columns).
• Figure 3: (a) Graph presentation and (b) ZXCF of the 9-qubit code. The input in the graph (a), in the center, is shown in blue. In the ZXCF, the green nodes are those of standard ZX calculus notation, and the dotted blue lines are Hadamarded edges. Note that the graph encoder uses a slightly different basis since its output edges do not contain Hadamard gates.
• Figure 4: (a) Graph presentation and (b) ZXCF of the 7-qubit code. The input in the graph (a), given by the leftmost node, is shown in blue. The ZXCF in (b) has standard ZX calculus green nodes, and dotted blue lines are Hadamarded edges. Note that the graph encoder uses a slightly different basis as since its output edges do not contain Hadamard gates.
• Figure 5: (a) Graph presentation and (b) ZXCF of the 5-qubit code. The input in the graph (a), in the center, is shown in blue. The ZXCF (b) has standard green ZX calculus nodes and dotted blue lines are Hadamarded edges.

Theorems & Definitions (81)

• Theorem 1.1: Informal
• Theorem 1.2: Informal
• Theorem 1.3: Informal
• Definition 2.1
• Definition 2.2
• Theorem 2.3
• Theorem 2.4
• Definition 4.1: Neighbour sets
• Lemma 4.2: ZX-graph rule
• proof