PaperlayerView exact revision on arXiv

Source-linked AI summary

Topological and subsystem codes on low-degree graphs with flag qubits

Christopher Chamberland, Guanyu Zhu, Theodore J. Yoder, Jared B. Hertzberg, Andrew W. Cross

arXiv:1907.09528v2quant-phcond-mat.mes-hallcond-mat.str-el

TL;DR

Superconducting implementations of standard codes face frequency-collision challenges from higher-degree connectivity. The paper introduces heavy hexagon and heavy square codes on low-degree graphs and a scalable flag-aware decoder; simulations report competitive thresholds while correcting errors up to full code distance.

  • Problem

    Standard surface-code layouts require degree-four connectivity and at least five distinct frequencies, creating frequency-collision challenges in superconducting architectures.

  • Method

    The paper maps hybrid surface/Bacon-Shor and surface-code families onto heavy low-degree lattices and incorporates flag-qubit outcomes into minimum-weight perfect matching decoding.

  • Results

    The heavy square code achieves approximately pth = 0.003, while the heavy hexagon code achieves an X-error threshold of pth = 0.0045.

  • Takeaways & Limitations

    Flag-aware decoding extends fault-tolerant correction up to the full code distance and makes low-degree topological and subsystem codes suitable for superconducting hardware.

Abstract

from arXiv · show

In this work we introduce two code families, which we call the heavy hexagon code and heavy square code. Both code families are implemented by assigning physical data and ancilla qubits to both vertices and edges of low degree graphs. Such a layout is particularly suitable for superconducting qubit architectures to minimize frequency collisions and crosstalk. In some cases, frequency collisions can be reduced by several orders of magnitude. The heavy hexagon code is a hybrid surface/Bacon-Shor code mapped onto a (heavy) hexagonal lattice whereas the heavy square code is the surface code mapped onto a (heavy) square lattice. In both cases, the lattice includes all the ancilla qubits required for fault-tolerant error-correction. Naively, the limited qubit connectivity might be thought to limit the error-correcting capability of the code to less than its full distance. Therefore, essential to our construction is the use of flag qubits. We modify minimum weight perfect matching decoding to efficiently and scalably incorporate information from measurements of the flag qubits and correct up to the full code distance while respecting the limited connectivity. Simulations show that high threshold values for both codes can be obtained using our decoding protocol. Further, our decoding scheme can be adapted to other topological code families.

I. INTRODUCTION

The paper targets superconducting architectures whose degree-four connectivity requires many frequencies and risks frequency collisions. It introduces low-degree heavy-hexagon and heavy-square codes, using extra ancillas as flag qubits to retain fault-tolerant decoding performance.

  • Motivation: Superconducting surface-code layouts use degree-four vertices, requiring at least five distinct frequencies for addressability and crosstalk avoidance.This creates a significant implementation challenge for superconducting circuits.
  • Code families: The proposed heavy hexagon and heavy square families reduce the distinct number of bulk frequencies to three using low-degree graphs.The heavy hexagon mixes degree-two and degree-three vertices, while the heavy square mixes degree-two and degree-four vertices.
  • Trade-off: Reducing connectivity introduces additional ancillas that deepen syndrome-extraction circuits and may increase logical error rates.These ancillas also provide resources for flag-based decoding.
  • Flag decoding: Flag-qubit measurements enable scalable decoding that corrects errors up to the full code distance.The approach extends flag-qubit fault-tolerance schemes from small codes to topological and subsystem codes.
  • Results: The heavy square code reaches approximately 0.3% thresholds for both X and Z errors, while the heavy hexagon code reaches approximately 0.45% for X errors.The heavy hexagon has no Z-error threshold under its Bacon-Shor-type decoding, although low logical errors were observed.

II. HEAVY HEXAGON AND HEAVY SQUARE CODES

The construction reduces graph connectivity by adding ancillas that split a degree-four vertex into lower-degree vertices. This can reduce frequency collisions in cross-resonance implementations.

  • Connectivity reduction: A degree-four vertex can be reduced to degree three by adding an ancilla and entangling it with the original ancilla.The transformation represents ancillas and data qubits as graph vertices while lowering connectivity by one.
  • Hardware motivation: Lower vertex degree can reduce the number of frequency collisions during two-qubit cross-resonance gates.The motivation is that higher-degree vertices require more frequencies.

A. Heavy hexagon code

The heavy hexagon code is a subsystem code on a heavy hexagonal lattice, combining surface-code and Bacon-Shor structures. Its flag-aware circuits and decoder preserve correction up to the full code distance despite low connectivity.

  • Lattice and layout: About 60% of heavy-hexagon qubits have degree two, and the average qubit degree is 12/5.The remaining qubits have degree three, improving connectivity relative to the degree-four square lattice.
  • Lattice and layout: The code encodes one logical qubit with data qubits arranged on an effective square lattice.For distance d, its parameters are [[d2, 1, d]].
  • Gauge structure: Its gauge group contains weight-two Z-type generators, weight-four bulk X-type generators, and weight-two boundary X-type generators.These generators correct bit-flip and phase errors, respectively.
  • Stabilizers: Products of weight-two Z-type gauge generators form bulk weight-four surface-code stabilizers.The factorization reduces syndrome-measurement circuit depth and error propagation.
  • Measurement circuits: The circuit uses two flag qubits for weight-four X-type gauge measurements and an 11-time-step CNOT schedule.Flag qubits identify weight-two data errors caused by single faults.
  • Decoding: Minimum-weight perfect matching uses decoding graphs whose edge weights are w_E = -log P_E, with flag outcomes represented by additional vertices.The flag-aware decoder uses these outcomes to correct errors up to the full code distance.

B. Heavy square code

The heavy square code maps the rotated surface code onto a low-degree lattice by adding flag qubits, while adapting stabilizer measurement circuits and matching graphs to fault-tolerant decoding.

  • Code construction: The heavy square code adds two flag qubits to each bulk stabilizer measurement, producing a lattice with average qubit degree 8/3.The distance-d family has parameters [[d^2, 1, d]] and uses d^2 data qubits plus 2d(d − 1) flag and syndrome measurement qubits.
  • Measurement circuits: Stabilizer measurements use 14 time steps, compared with 11 for the heavy hexagon code, because both heavy-square stabilizers have weight four.
  • Fault tolerance: A heavy-square CNOT schedule cannot ensure that all flagged weight-two errors are orthogonal to same-type logical operators, making flag information important for decoding.This scheduling constraint is specific to the reduced-degree architecture with flag qubits.
  • Layout and scheduling: The CNOT schedule determines the placement of data, flag, and syndrome qubits and assigns X- and Z-stabilizer measurements to distinct lattice faces.Data qubits are shown as yellow vertices, flag qubits as white vertices, syndrome qubits as dark vertices, and stabilizer faces as red or blue.

C. The cross resonance gates and frequency collision reduction

The codes are designed for superconducting architectures using cross-resonance gates, where low-degree layouts reduce frequency crowding while supporting hardware-specific CNOT scheduling and flag-based decoding.

  • Flag-based decoding: The heavy-square matching graphs incorporate flag outcomes and connect measurement-round graphs with diagonal and vertical edges for correlated faults.
  • Cross-resonance implementation: Cross-resonance gates implement CNOTs with microwave pulses, and their direction is fixed by the relative frequencies of neighboring qubits.Hadamard conjugation can reverse selected CNOT directions for code-measurement circuits.
  • Frequency-efficient layouts: The heavy hexagon and heavy square codes require fewer distinct frequencies than the rotated surface code, which requires five frequencies on degree-four vertices.
  • Collision analysis: The heavy and rotated surface codes are compared by mean collision count versus fabrication frequency precision σf using more than 10^3 Monte Carlo repetitions.The collision model compares frequency crowding consistently but does not quantify gate errors.
  • Collision analysis: The heavy hexagon and heavy square codes show similar collision behavior at each distance and outperform the rotated surface code in the reported comparison.The rotated surface code uses 10–20% fewer qubits but requires nearly twice the frequency precision to eliminate collisions.

III. DECODING THE HEAVY HEXAGON AND HEAVY SQUARE CODES USING FLAG QUBITS

The decoding protocol incorporates flag-qubit outcomes into minimum-weight perfect matching, preserving efficient decoding while correcting fault patterns up to the full code distance. The analysis establishes this behavior for heavy hexagon and heavy square codes and extends it to broader topological settings.

  • Flag information: A single fault during weight-four Pauli measurements can create a weight-two data-qubit error together with a flag outcome.The decoder uses these flag outcomes to identify affected boomerang edges in the matching graph.
  • Flag-aware matching: The protocol leaves flagged boomerang-edge weights unchanged while renormalizing probabilities and weights for edges outside highlighted boomerangs.It then constructs a reweighted graph and identifies highlighted vertices from syndrome changes across consecutive rounds.
  • Flag-aware matching: Minimum-weight perfect matching on the reweighted graph pairs highlighted vertices, finds minimum-weight connecting paths, and applies corrections to the remaining highlighted edges.For repeated syndrome rounds, the resulting highlighted edges are mapped to the corresponding planar graph when required.
  • Fault tolerance: The reweighted probabilities are not always the true probabilities for edges outside boomerangs, potentially assigning excessive weight to paths involving flagged configurations.Despite this mismatch, the authors show that configurations arising from at most floor((d−1)/2) faults are corrected.
  • Generalization: The flag decoder achieves fault tolerance up to the full code distance for suitable topological stabilizer codes on genus-g surfaces with open boundaries and holes.The result includes the heavy-square construction and extends to the heavy-hexagon subsystem code, while twist-defect cases remain incomplete.

IV. NUMERICAL RESULTS

Monte Carlo simulations evaluated logical error rates for both code families across odd distances, showing competitive thresholds and a strong benefit from retaining flag-qubit information. The heavy hexagon code has asymmetric X/Z performance, while the heavy square code retains high thresholds despite deeper stabilizer-measurement circuits.

  • Simulation setup: 107 Monte Carlo simulations evaluated heavy hexagon and heavy square logical X and Z error rates for odd distances 3 ≤ d ≤ 13.The simulations used the paper’s depolarizing noise model and flag-aware decoding protocol.
  • Heavy hexagon results: The heavy hexagon code has no logical Z threshold, although its logical Z error rate decreases significantly near physical error rates of 10^-4.Z errors are corrected using Bacon-Shor-type stabilizers.
  • Heavy hexagon results: 0.0045 is the heavy hexagon code’s logical X-error threshold, described as fairly competitive with surface-code results.X errors are corrected using a surface-code-type decoding scheme.
  • Heavy square results: 0.003 is the computed asymptotic threshold for both logical X and Z errors in the heavy square code.This remains high despite stabilizer-measurement circuit depth 14 versus 6 for the surface code.
  • Flag-information comparison: Ignoring flag measurements reduces the heavy square logical X threshold to approximately 0.002 and makes logical Z error rates about an order of magnitude worse.The logical X threshold is less than half the value obtained when flag information is used.

V. CONCLUSION

The paper introduces heavy hexagon and heavy square code families that combine low-degree layouts with flag-qubit decoding. They reduce frequency-collision exposure while retaining full-distance correction and competitive threshold behavior, with broader extensions left for future work.

  • Code families: The heavy hexagon code is a hybrid surface/Bacon-Shor code, while the heavy square code is a surface code mapped onto a heavy square lattice.The heavy hexagon uses weight-four X-type gauge generators and products of weight-two Z-type gauge generators.
  • Hardware implications: For a given distance d, the two implementations use 10 to 20% more qubits than a rotated surface code but achieve nearly an order of magnitude fewer frequency collisions.They can also accept roughly twice the fabrication-related frequency disorder while remaining collision-free.
  • Fault tolerance: Flag-qubit information enables scalable decoding that corrects errors up to the full code distance.The conclusion reports this as a key ingredient in fault-tolerant implementation of the weight-four measurements.
  • Threshold results: Under depolarizing noise, the heavy square code has an approximately 0.003 threshold, while the heavy hexagon code has a 0.0045 X-error threshold and no Z-error threshold.The heavy hexagon can nevertheless achieve low logical error rates for physical error rates on the order of 10^-4.
  • Scope and future work: The flag-qubit decoding scheme is extended to nonzero-genus surfaces, while applications to higher-weight stabilizer codes, twist defects, general subsystem codes, and leakage errors remain future directions.The proposed edge-probability optimization is expected to depend strongly on the underlying stabilizer-measurement noise model.

Appendix A: Edge weights calculations for the matching graphs

Appendix A derives matching-graph edge weights for the heavy hexagon and heavy square decoding graphs from scheduled-gate error propagation and relevant error configurations. It also identifies how flags activate special graph edges and how Bacon-Shor decoding differs from surface-code decoding.

  • Purpose: The appendix provides examples and complete edge weights for graphs used to correct X- and Z-type Pauli errors.These graphs correspond to the heavy hexagon and heavy square code constructions.
  • Heavy hexagon weights: CNOT fault propagation through scheduled parity-measurement circuits determines the probabilities assigned to matching-graph edges.The appendix analyzes bulk CNOT gates and how propagated data errors affect highlighted syndrome measurement qubits.
  • Bacon-Shor decoding: For heavy-hexagon X-type gauge measurements, only odd error-configurations matter because the decoder uses Bacon-Shor-type codes.The edge probabilities sum over all odd configurations producing each edge type.
  • Graph structure: The heavy-hexagon Z-stabilizer graph includes diagonal edges, a flag-activated cross edge, and a vertical 3DV edge for measurement errors.TLBR and BLTR denote the two diagonal directions.
  • Heavy square weights: The heavy-square X- and Z-stabilizer edge probabilities match the heavy-hexagon values except for the 3DV measurement-error edge.The appendix gives a separate expression for that edge probability in both heavy-square graphs.

Appendix B: Encoding logical qubits into a high-genus surface and a surface with hole defects

Appendix B constructs heavy-square codes on high-genus surfaces and surfaces with hole defects. This construction proves the stated theorem and exhibits an encoding scheme for multiple logical qubits in one code block.

  • Construction: The appendix explicitly constructs heavy-square codes on high-genus surfaces and surfaces with hole defects.The construction is used to prove Theorem 1.
  • Encoding: The construction demonstrates how multiple logical qubits can be encoded into a single code block.The resulting encoding scheme can facilitate logical gate operations.

1. High-genus surface

The paper constructs high-genus surfaces by gluing two punctured heavy-code layers, producing logical strings along non-contractible cycles. The resulting architecture supports distance-aware flag decoding and can be implemented with experimentally feasible inter-layer couplings.

  • Construction: Two layers of punctured heavy-hexagon codes are glued by identifying corresponding qubits along hole boundaries and outer edges.The identified qubits are experimentally implemented as a single qubit.
  • Construction: Vertically aligned X- and Z-type plaquettes are switched between layers so neighboring plaquettes retain alternating stabilizer types.
  • Logical structure: The illustrated genus-3 surface has logical strings with minimum supports 6, 4, and 4, giving code distance d = 4.The code distance equals the systole, the shortest non-contractible loop.
  • Error correction: The flag decoder corrects up to ⌊(d −1)/2⌋ faults, corresponding to errors with weight less than half the systole length.Because measured operators have weight at most four, weight-two errors from one fault lie on boomerang edges.
  • Implementation: A bi-layer superconducting architecture can use flip-chip, bumpbond, or thru-substrate-via technologies for inter-layer coupling.Stabilizers near glued punctures require vertical inter-layer couplings.
  • Code deformation: Mapping-class-group code deformations use Dehn twists, implementable in O(1) time with long-range connectivity or O(d) time with local connectivity.

2. Hole defects

The paper presents planar hole defects as an experimentally feasible way to encode multiple logical qubits in a single-layer code. Smooth and rough defects realize the two standard surface-code logical-qubit types through distinct boundary stabilizers.

  • Motivation: A single-layer planar code with hole defects provides an experimentally feasible alternative for encoding multiple logical qubits.
  • Defect types: Smooth defects correspond to Z-cut logical qubits, while rough defects correspond to X-cut logical qubits.These defect types are equivalent to the corresponding defects in standard surface codes.
  • Boundary stabilizers: Smooth-defect boundaries use only X-type weight-two stabilizers, whereas rough-defect boundaries use only Z-type weight-two stabilizers.
Loading 1907.09528v2…