A Fault-Tolerant Honeycomb Memory

TL;DR

This work assesses the robustness of Hastings–Haah’s honeycomb quantum memory, which uses 2-body measurements to implement 6-body parity checks and stores dynamic logical qubits, by employing a correlated MWPM decoder and extensive Monte Carlo simulations. It benchmarks the honeycomb code against the rotated surface code across three circuit-level error models, revealing threshold ranges from $0.1\%$ to $2.0\%$ depending on the model and decoding approach, and introduces the teraquop qubit count as a practical finite-size metric. Notably, with native two-body measurements the honeycomb code achieves a teraquop regime with as few as $600$ physical qubits at $p=10^{-3}$, highlighting potential hardware advantages despite generally higher overhead in some models. The study also demonstrates how including decoder correlations improves error suppression (lambda) and discusses planar and rotated variants as avenues to further reduce qubit overhead, while acknowledging boundary effects and model dependencies on performance.

Abstract

Recently, Hastings & Haah introduced a quantum memory defined on the honeycomb lattice. Remarkably, this honeycomb code assembles weight-six parity checks using only two-local measurements. The sparse connectivity and two-local measurements are desirable features for certain hardware, while the weight-six parity checks enable robust performance in the circuit model. In this work, we quantify the robustness of logical qubits preserved by the honeycomb code using a correlated minimum-weight perfect-matching decoder. Using Monte Carlo sampling, we estimate the honeycomb code's threshold in different error models, and project how efficiently it can reach the "teraquop regime" where trillions of quantum logical operations can be executed reliably. We perform the same estimates for the rotated surface code, and find a threshold of $0.2\%-0.3\%$ for the honeycomb code compared to a threshold of $0.5\%-0.7\%$ for the surface code in a controlled-not circuit model. In a circuit model with native two-body measurements, the honeycomb code achieves a threshold of $1.5\% < p <2.0\%$, where $p$ is the collective error rate of the two-body measurement gate - including both measurement and correlated data depolarization error processes. With such gates at a physical error rate of $10^{-3}$, we project that the honeycomb code can reach the teraquop regime with only $600$ physical qubits.

Figures (10)

• Figure 1: The honeycomb code. The layout is a straightened-out hexagonal tiling of the torus with faces 3-colored red (Pauli X), green (Pauli Y), and blue (Pauli Z). Edges are assigned the color of the faces they span between. There is a data qubit at each vertex and, optionally, a measurement ancilla qubit at the center of each edge. Each edge represents a 2-body measurement and each face represents a 6-body parity check (stabilizer). Note that the parity checks commute with all of the edge operators, and so are preserved when measuring them. As a static subsystem code, this construction protects no degrees of freedom. The code progresses in repeating rounds, with each round made up of three sub-rounds. In each sub-round, all the edge parities of one type are measured: first red (X), then green (Y), then blue (Z). The 6-body parity checks are assembled as the product of the six edges that form their perimeter (measured in consecutive sub-rounds). The logical qubit's two anti-commuting observables travel along paths highlighted in black and orange. As the edges along each observable's path are measured, those measurement results are multiplied into the observable to prevent it from anti-commuting with the next sub-round's edge measurements. Consequently, the specific observables along each path change from sub-round to sub-round, cycling with a period of six sub-rounds (two full rounds). Note that there is a second pair of nonequivalent anti-commuting logical observables, defined along the same paths but offset by three sub-rounds, making for a total of two encoded logical qubits. For simplicity, in our analysis, we only consider preserving one of these two.
• Figure 2: Teraquop plots showing the physical qubits per logical qubit required to reach the teraquop regime (one-in-a-trillion per-logical-operation error rates) using both standard (uncorrelated) and correlated minimum-weight perfect-matching. SD6 is a standard circuit error model, SI1000 is a superconducting-inspired circuit error model, and EM3 is a circuit error-model with primitive two-body measurements (see \ref{['sec:error_models']}). These values are extrapolated from the line fits in \ref{['fig:linefits']}. Highlighted regions correspond to values that the underlying line fit can be forced to imply while increasing its sum of squares error by at most one (in the natural basis). Some discretization effects are visible due to the gaps between achievable code distances.
• Figure 3: Pipelining in honeycomb circuits. Left: 3 rounds (9 sub-rounds) of the EM3 honeycomb circuit, which does not require pipelining. Vertical flat red/green/blue rectangles are $XX$/$YY$/$ZZ$ parity measurements. Vertical black poles represent data qubits. Right: 3 rounds (9 sub-rounds) of the SD6 honeycomb circuit, which is pipelined (meaning operations from different rounds and sub-rounds occur during the same time step) to reduce depth. Vertical flat red/green/blue rectangles are CNOT gates targeting the measurement ancilla at the center of an edge, with the color indicating the current transformed basis of the data qubit. Vertical black poles are data qubits. White, yellow, and black boxes are reset operations, measurement operations, and $C_{ZYX}$ operations (the Clifford operation that rotates -120 degrees around $X+Y+Z$) respectively. A sketchup file containing this 3d model is attached to the paper as an ancillary file named "3d_order.skp".
• Figure 4: The matching graph, computed automatically by Stim, for the 10-round 4x6-data-qubit SD6 honeycomb code circuit initializing and measuring the vertical observable. Nodes correspond to detectors (potential detection events) declared in the circuit. Edges correspond to error mechanisms that set off two detection events. Edges wrapping around due to the periodic boundary conditions are shown terminating in empty space. Nodes flipped by an error mechanism that sets off exactly one detection event are indicated by showing the associated node as a large black box. Due to the periodic spatial boundaries, these only occur at the time boundaries of the matching graph that's missing initialization and terminal measurement detectors. Note that for an error to wrap around the lattice yielding a logical failure, at least four edges must be traversed, consistent with the expected effective distance of 4. Left: The connected component of the matching graph that corrects errors that commute with the observable we're preserving. Center: The connected component of the matching graph that corrects errors that anti-commute with the observable we're preserving. Edges highlighted in green correspond to errors that flip the specific logical observable annotated in the circuit. Right: The complete matching graph. The graph has degree at most 12, similar to the surface code. By contrast, the EM3 honeycomb circuits produce matching graphs with nodes of degree 18 due to additional correlated errors.
• Figure 5: Threshold plots showing failure rates per code cell for one of the observables in the honeycomb code and the surface code under various error models. For more cases, see \ref{['fig:threshold_all']} in the appendix. By "code cell", we mean a spacetime region with a spacelike extent that realizes a code distance of $d$, and a timelike extent of $d$ rounds. We simulate $3d$ rounds (but report the error rate per $d$ rounds) to minimize time-boundary effects. Our honeycomb code description on a torus only realizes distances that are multiples of four. Highlighted areas correspond to hypotheses whose likelihoods are within a factor of 1000 of the maximum likelihood estimate. The large highlighted areas above threshold are due to aggressive termination of sampling when logical error rates near 50% are detected, resulting in less samples.