Vine Codes: Planar Quantum LDPC

• Vine codes are quantum LDPC codes defined by local, dynamic syndrome extraction where a measure qubit ‘walks’ to generate vine-shaped stabilizer supports.
• They are implemented on planar square-grid architectures with nearest-neighbor two-qubit gates and routing qubits to handle open-boundary conditions.
• Vine codes offer reduced qubit overhead and improved circuit distance compared to surface codes, promising better error performance on superconducting hardware.

Searching arXiv for the cited Vine Codes paper and closely related work. Vine codes are a family of quantum low-density parity-check stabilizer codes designed for planar square-grid architectures with nearest-neighbour two-qubit gates native to superconducting hardware, specifically iSWAP- and CZ-compatible operations. They were introduced as a route to reducing the qubit overhead of the surface code without sacrificing planar locality, and are formulated as open-boundary generalizations of earlier directional-code constructions on a torus. Their defining mechanism is a syndrome-extraction circuit in which measure qubits dynamically “walk” through the lattice, so that extended stabilizer supports are generated by local interactions alone; the resulting supports have a characteristic vine-like geometry (Nixon et al., 18 Jun 2026).

1. Definition and architectural setting

Vine codes belong to the broader class of quantum LDPC codes, but are distinguished by an explicit hardware constraint: they are implementable on a planar square grid through nearest-neighbour, two-qubit gates native to superconducting platforms. The construction therefore targets a regime in which long-range couplings, often assumed by other qLDPC proposals, are unavailable or undesirable. In this respect, vine codes occupy an intermediate position between the surface code, whose locality is already well matched to superconducting layouts, and more general qLDPC families, which can offer lower overheads but typically rely on nonlocal connectivity (Nixon et al., 18 Jun 2026).

The central claim of the construction is not merely that a planar code with nontrivial stabilizers exists, but that low-overhead qLDPC structure can be realized while preserving square-grid locality. The paper states that vine codes generalise “Directional Codes” recently introduced by Gehér et. al. (2025), which are constrained to a torus, whereas vine codes instead use open boundary conditions constructed with the aid of routing qubits. This shift from periodic to open boundaries is essential for finite planar patches and for comparison with the surface code as a practical benchmark (Nixon et al., 18 Jun 2026).

A further point of scope is terminological. In the arXiv literature, “vine” also denotes pair-copula constructions in statistics and machine learning, as in vine copula autoencoders, dynamic vine copulas, and related dependence models (Tagasovska et al., 2019, Cheng et al., 16 Jun 2025). By contrast, vine codes are a coding-theoretic and fault-tolerant-quantum-computing concept. This suggests that the phrase “vine code” should be read here as a specific qLDPC code family, not as a latent-code model, a dataset annotation scheme, or a copula factorization.

2. Circuit construction and stabilizer growth

A vine code is specified by two ingredients: a layout giving the initial placement of $X$-type and $Z$-type measure qubits on the square grid, and a step sequence giving an ordered list of local gate instructions. The paper defines eight step symbols. The uppercase symbols $\vec{N}, \vec{E}, \vec{S}, \vec{W}$ use CXSWAP gates, so qubit positions can move; the lowercase symbols $\vec{n}, \vec{e}, \vec{s}, \vec{w}$ use CX gates only, so qubits do not move. Up to single-qubit Cliffords, the CXSWAP operations provide iSWAP-like routing and entangling behavior, while CX provides CZ-like behavior. The measure qubit’s Pauli type fixes control-target orientation: $Z$-measure qubits are always the target, and $X$-measure qubits are always the control (Nixon et al., 18 Jun 2026).

The mechanism by which stabilizers acquire extended support is a dynamic walk of the measure qubit through the lattice during syndrome extraction. As the measure qubit follows its step sequence, it interacts with successive nearby data qubits, and the stabilizer support grows along the path traversed. The paper illustrates this with the sequence

$\overrightarrow{nSewSs},$

for which the qubit first entangles without moving, then swaps, then continues walking and entangling, producing a vine-shaped stabilizer. This is the origin of the family name. Because every constituent gate is local, the extended support is not imposed geometrically at the hardware level but synthesized temporally by the measurement circuit (Nixon et al., 18 Jun 2026).

For ordinary vine codes, the motion is two-round periodic: the measure qubit takes the reverse path in even quantum error-correction rounds and returns to its starting position after two rounds. This periodic walk is part of the standard construction and is tied to how stabilizer measurement is repeated while keeping the layout local and reusable (Nixon et al., 18 Jun 2026).

Not every layout-step pair defines a valid code. The paper lists four validity conditions: commutativity, independent measurement, topological order, and patch connectivity. Commutativity requires that stabilizers of opposite type have even overlap. Independent measurement excludes interleavings that would obstruct clean syndrome extraction. Topological order requires logical operators whose weight grows with system size. Patch connectivity requires that the boundary-cut patch not split into disconnected code regions. The paper also defines a set $\Delta_{\text{odd}}$ of displacement vectors diagnosing dangerous overlaps in the circuit-level construction (Nixon et al., 18 Jun 2026).

3. Open boundaries, routing qubits, and planar patches

The passage from toric directional codes to planar vine codes is mediated by open boundaries and routing qubits. Open boundaries matter because a torus is mathematically convenient but not physically ideal for a planar superconducting chip. Routing qubits are introduced to preserve nearest-neighbour connectivity near boundaries and to allow measure and data qubits to continue their local walk when the ideal infinite-lattice path is cut by the boundary. In the paper’s terminology, routing qubits can be data qubits outside the active patch but still needed for motion, or measure qubits that have been demoted to routing status (Nixon et al., 18 Jun 2026).

The first open-boundary construction uses Pauli boundaries, analogous to the $X$- and $Z$-boundaries of the surface code. If a patch is defined by parallelogram vectors $Z$0 and $Z$1, then the boundaries along $Z$2 and $Z$3 are one Pauli type, while the boundaries along $Z$4 and $Z$5 are the other. Stabilizers fully outside the patch are removed; stabilizers crossing the “wrong” boundary are removed; and stabilizers crossing the “right” boundary are truncated to their in-patch support. This reproduces the standard logic that one type of topological string can terminate on a given boundary and the other cannot (Nixon et al., 18 Jun 2026).

Near a boundary, missing neighbours force modifications to the ideal trajectory. If a qubit must step in a direction $Z$6 but the intended neighbour has been removed, a routing qubit is placed there and the intended entangling operation is replaced by a SWAP. The paper further notes an optimization in which SWAPs can be implemented via CZSWAP with reset and measurement tricks, and many SWAPs can be removed if unnecessary. In one example, this reduced the routing-qubit count by as much as $Z$7: for the distance-10 $Z$8 patch, routing qubits were reduced from 198 to 67 after optimization (Nixon et al., 18 Jun 2026).

The paper also expands beyond Pauli boundaries and constructs generalized open boundaries. In particular, it discusses boundaries for codes equivalent to the 2D color code using an anyon-condensation framework in which condensed tunnelling operators form a Lagrangian subgroup. For the code $Z$9, three colors $\vec{N}, \vec{E}, \vec{S}, \vec{W}$0, nine nontrivial bosons, and six boundary types are described, yielding colored-boundary behavior beyond the familiar $\vec{N}, \vec{E}, \vec{S}, \vec{W}$1 boundary dichotomy of the surface and tile codes. This suggests that vine-code boundary theory is not limited to surface-code analogues.

4. Code parameters, search results, and classification

The paper reports extensive numerical searches for candidate vine codes and verifies their circuit distances. Among the representative finite patches highlighted are $\vec{N}, \vec{E}, \vec{S}, \vec{W}$2, $\vec{N}, \vec{E}, \vec{S}, \vec{W}$3, $\vec{N}, \vec{E}, \vec{S}, \vec{W}$4, and $\vec{N}, \vec{E}, \vec{S}, \vec{W}$5. More specifically, the sequence $\vec{N}, \vec{E}, \vec{S}, \vec{W}$6 on a horizontal parallelogram gives

$\vec{N}, \vec{E}, \vec{S}, \vec{W}$7

with $\vec{N}, \vec{E}, \vec{S}, \vec{W}$8; $\vec{N}, \vec{E}, \vec{S}, \vec{W}$9 on a rotated patch gives

$\vec{n}, \vec{e}, \vec{s}, \vec{w}$0

with $\vec{n}, \vec{e}, \vec{s}, \vec{w}$1; and $\vec{n}, \vec{e}, \vec{s}, \vec{w}$2 on a horizontal parallelogram gives

$\vec{n}, \vec{e}, \vec{s}, \vec{w}$3

with $\vec{n}, \vec{e}, \vec{s}, \vec{w}$4 (Nixon et al., 18 Jun 2026).

A notable methodological point is that the emphasis is on circuit distance rather than code distance alone. Circuit distance is defined as the minimum weight of an undetectable logical fault in the actual syndrome-extraction circuit, including hook errors and routing effects. The paper states that circuit distances were verified using the exact distance finder based on the connected-cluster algorithm in dist-m4ri. In the verified examples, many patches satisfy

$\vec{n}, \vec{e}, \vec{s}, \vec{w}$5

and the authors identify examples with no distance-reducing hook errors (Nixon et al., 18 Jun 2026).

The classification effort is also unusually explicit. The paper performs an exhaustive search over valid vine-code sequences up to stabilizer weight 9. It finds 147 step sequences up to and including weight 9; before support-symmetry reductions there are 906 sequences; and after filtering equivalent representatives, 146 valid canonical representatives remain in the final table. Uniqueness is defined after quotienting by $\vec{n}, \vec{e}, \vec{s}, \vec{w}$6 symmetry—rotations and reflections—and by support-equivalent sequences that generate the same stabilizer support with different step orderings. The authors stress that support equivalence does not imply identical hook-error behavior, so canonical representatives are not always the best-performing instances (Nixon et al., 18 Jun 2026).

5. Overhead reduction and noise performance

The principal benchmark throughout the paper is the surface code. For $\vec{n}, \vec{e}, \vec{s}, \vec{w}$7 rotated surface-code patches, the comparison baseline is

$\vec{n}, \vec{e}, \vec{s}, \vec{w}$8

Against this reference, vine codes are reported to reduce overhead while preserving planar locality. The paper states reductions of up to $\vec{n}, \vec{e}, \vec{s}, \vec{w}$9 in data plus measure qubits at circuit distance $Z$0, and about $Z$1 in total qubits including routing at distance $Z$2. It further states that the benefits are expected to increase at higher distances. The best overhead depends strongly on boundary geometry—rotated, square, horizontal parallelogram, or vertical parallelogram—and codes with similar local walk rules can have markedly different finite-patch efficiencies depending on the chosen cut (Nixon et al., 18 Jun 2026).

The asymptotic comparison is framed through polynomial fits in the code distance $Z$3. Both the surface code and vine codes have quadratic leading behavior, but the relevant criterion is whether the fitted quadratic coefficient $Z$4 satisfies

$Z$5

When this holds, the paper argues that the vine code should become increasingly advantageous relative to the surface code as $Z$6 grows (Nixon et al., 18 Jun 2026).

Circuit-level noise simulations are carried out under a superconducting-inspired SI1000 model. After each gate layer, two-qubit gates receive a correlated two-qubit depolarizing channel of strength $Z$7; Hadamards receive single-qubit noise of strength $Z$8; resets in the $Z$9 or $X$0 basis are followed by error channels of strength $X$1; measurements suffer classical readout error with probability $X$2; and idling qubits receive depolarizing noise of strength $X$3 during unitary layers and $X$4 during measurement/reset layers. Simulations use $X$5 as the near-term comparison point. Vine codes are decoded with BPOSD, while the surface code is decoded with PyMatching (Nixon et al., 18 Jun 2026).

Under this model, the paper reports that vine codes can perform better than or comparably to the surface code while using fewer qubits. In particular, for the $X$6-memory example based on $X$7, the logical error rate is reported to outperform the corresponding surface code by nearly an order of magnitude in that setting. A cautious interpretation is that the principal significance of vine codes lies not in asymptotic distance scaling alone, but in the possibility of shifting the practical constant factors of planar fault tolerance.

6. Flip-vine codes and generalized logical structure

The paper introduces flip-vine codes as a variant designed to support single-qubit transversal Clifford gates. In a flip-vine code, a measure qubit measures one Pauli type in odd rounds and the opposite Pauli type in even rounds while tracing the reverse step sequence. Thus a stabilizer measured as $X$8 in one round is measured as $X$9 in the next round on the same support. The resulting code is weakly self-dual (Nixon et al., 18 Jun 2026).

Weak self-duality has direct logical consequences. The paper states that it implies a transversal Hadamard acting on all data qubits, and, with suitable bipartition conditions, a transversal $\overrightarrow{nSewSs},$0 gate. It further states that all flip-vine codes found in the search admit a suitable bipartition, and that weight-8 stabilizer codes admit a trivial one. The intended application is fault-tolerant Clifford logic and magic-state cultivation. Because each active measure qubit now supports both an $\overrightarrow{nSewSs},$1 and a $\overrightarrow{nSewSs},$2 stabilizer across alternating rounds, about half the measure qubits are active and the rest serve as routing qubits (Nixon et al., 18 Jun 2026).

Representative periodic-boundary flip-vine examples listed in the paper include $\overrightarrow{nSewSs},$3 with $\overrightarrow{nSewSs},$4, $\overrightarrow{nSewSs},$5 with $\overrightarrow{nSewSs},$6, $\overrightarrow{nSewSs},$7 with $\overrightarrow{nSewSs},$8, $\overrightarrow{nSewSs},$9 with $\Delta_{\text{odd}}$0, $\Delta_{\text{odd}}$1 with $\Delta_{\text{odd}}$2, and $\Delta_{\text{odd}}$3 with $\Delta_{\text{odd}}$4. The paper reports very strong qubit savings relative to toric-code implementations, with $\Delta_{\text{odd}}$5 as low as $\Delta_{\text{odd}}$6, $\Delta_{\text{odd}}$7, $\Delta_{\text{odd}}$8, and $\Delta_{\text{odd}}$9, depending on the example (Nixon et al., 18 Jun 2026).

The paper also emphasizes limitations. It notes that asymptotically, 2D translationally invariant codes cannot beat $X$0 scaling; routing qubits still impose overhead; implementing both high-fidelity iSWAP and CZ simultaneously remains challenging; optimal decoders and fault-tolerant logical operations for multi-logical-patch vine-code architectures remain open problems; and generalized boundaries and more exotic patch shapes are still largely unexplored. This suggests that vine codes are best understood as a planar-local qLDPC design point with promising finite-distance tradeoffs, rather than as a general escape from two-dimensional coding bounds.