Two-Level Iceberg Codes in QEC

• The paper presents a novel two-level concatenation method that transforms distance-2 iceberg codes into a distance-4 quantum error-correcting scheme while preserving a high logical rate.
• The construction employs a grid-based layout where inner and outer iceberg codes yield rectangle logical operators, enhancing fault tolerance through specialized decoding of generalized weight errors.
• Experimental benchmarks on a 98-qubit trapped-ion processor demonstrate improved SPAM, QEC-cycle, and GHZ state preparation with zero logical errors in key trials.

Searching arXiv for the specified paper to ground the article and citation. Two-level iceberg codes are two-level concatenated iceberg quantum error-correcting codes obtained by concatenating two distance-2 iceberg quantum error-detecting codes. In the formulation implemented experimentally, the base iceberg code $I{k}$ encodes an even number $k$ of logical qubits into $n=k+2$ physical qubits with code distance $d=2$, and the two-level concatenated family has parameters $[(k_2+2)(k_1+2),\,k_2k_1,\,4]$. The construction preserves the high logical rate of the underlying iceberg family while promoting error detection to distance-4 quantum error correction, and it is accompanied by specialized gadgets for encoded preparation, syndrome extraction, and logical operations on trapped-ion hardware (Dasu et al., 25 Feb 2026).

1. Base iceberg code and high-rate encoding

The underlying object is the iceberg code $I{k}$, described as a low-overhead quantum error-detecting code. It “encode[s] an even number, $k$, of logical qubits at code distance $d=2$ using only two additional qubits for a total of $n = k + 2$ physical qubits.” Its stabilizer generators are global parity operators,

$S_{X/Z} = \prod_{j=0}^{n-1}(X/Z)_j,$

and one generating set for logical operators is

$k$0

This makes the base code unusually compact: it detects any single-qubit error, yet its logical operators are weight-2. The combination of high logical rate and low-weight logical structure is the defining starting point for the concatenated construction. A plausible implication is that the code is especially well matched to platforms where long-range connectivity reduces the routing overhead that would otherwise erode the benefit of encoding.

2. Concatenation into a distance-4 code

Two-level iceberg codes arise by concatenating two iceberg codes $k$1 and $k$2. The paper defines a concatenation map $k$3 with parameters $k$4; because each constituent iceberg code has distance $k$5, the resulting code has distance $k$6. In the special case emphasized in the main text and abstract, this yields the explicit family

$k$7

The construction is called “two-level” because there are exactly two concatenation layers. First, inner $k$8 blocks are formed; second, an outer $k$9 structure is applied to the logical qubits of those inner blocks. The paper states that the procedure “can be straightforwardly iterated to higher levels to achieve larger distances,” but the reported implementation uses only “the first two concatenation levels,” corresponding to the transition from distance-2 quantum error detection to distance-4 quantum error correction (Dasu et al., 25 Feb 2026).

3. Grid construction, stabilizers, and rectangle logical operators

The concatenated code is visualized by arranging qubits in an $n=k+2$0 grid with Pauli operators labeled $n=k+2$1 and $n=k+2$2. The encoding proceeds in two stages: each row is first encoded into an $n=k+2$3 code, and then $n=k+2$4 codes are encoded on the $n=k+2$5 logical-qubit columns. This row-then-column organization determines both the stabilizer structure and the geometry of logical operators.

The stabilizers come in two classes. The low-level stabilizers are inherited from the inner $n=k+2$6 codes and act on rows: $n=k+2$7 The high-level stabilizers arise from the outer encoded $n=k+2$8 code: $n=k+2$9

The logical operators of $d=2$0 are rectangles: $d=2$1

$d=2$2

The paper explicitly states that “the $d=2$3 and $d=2$4 logical operators are rectangles of physical $d=2$5 or $d=2$6 operators.” In operational terms, the transition from weight-2 logicals in the base code to rectangle logicals in the concatenated code is the mechanism by which the distance increases from $d=2$7 to $d=2$8. This suggests that the row/column factorization is not merely a visual aid but the organizing principle behind both decoding and gadget design.

4. Distance-4 behavior and generalized-weight decoding

The distance-4 property is analyzed through a decoder adapted to the grid structure. The paper introduces notions of “generalized weight-two” and “generalized weight-one” errors to capture string-like faults aligned with rows or columns. For $d=2$9 errors, strings of the form $[(k_2+2)(k_1+2),\,k_2k_1,\,4]$0 and $[(k_2+2)(k_1+2),\,k_2k_1,\,4]$1 are called generalized weight-two; similarly for $[(k_2+2)(k_1+2),\,k_2k_1,\,4]$2 errors with $[(k_2+2)(k_1+2),\,k_2k_1,\,4]$3 and $[(k_2+2)(k_1+2),\,k_2k_1,\,4]$4. A product of a generalized weight-two $[(k_2+2)(k_1+2),\,k_2k_1,\,4]$5 error and a generalized weight-two $[(k_2+2)(k_1+2),\,k_2k_1,\,4]$6 error is also generalized weight-two because $[(k_2+2)(k_1+2),\,k_2k_1,\,4]$7 and $[(k_2+2)(k_1+2),\,k_2k_1,\,4]$8 errors are corrected independently.

The finer notion of generalized weight-one is used when the coordinate of the string is known. The paper defines the tuples $[(k_2+2)(k_1+2),\,k_2k_1,\,4]$9 and $I{k}$0 as generalized weight-one, corresponding respectively to a vertical error string with known $I{k}$1 coordinate and a horizontal error string with known $I{k}$2 coordinate.

This decoding framework is tied to the geometry of the rectangle logical operators. The paper stresses that strings and rectangles intersect in at most two sites, and this is why the concatenated code retains distance-4 behavior within the fault-tolerance analysis. A plausible implication is that the code’s correctability is best understood through structured fault classes rather than by naive physical Hamming weight alone (Dasu et al., 25 Feb 2026).

5. Encoded gadgets, fault tolerance, and postselection

A central contribution associated with two-level iceberg codes is a set of new gadgets for encoded operation.

For state preparation, the paper introduces “a new, FT two-branch $I{k}$3 state preparation gadget for concatenated iceberg codes $I{k}$4 which generalizes the $I{k}$5 circuit.” The construction prepares lower-level $I{k}$6 blocks using the distance-2 two-branch routine, then applies transversal logical CX gates between blocks, together with lower-level fault-detection gadgets so that a single failure causes at most a generalized weight-one error. The supplement notes that if the circuit passes, a single failure causes at most a weight-one error, while two failures can produce a generalized weight-two error.

For QEC, the paper replaces a Knill-style use of two full ancilla blocks per cycle with a lower-overhead recursive scheme. The stated procedure “generalizes the $I{k}$7 QEC protocol (with a Bell pair of ancilla) by replacing the physical ancilla qubits in that scheme with lower-concatenation-level $I{k}$8 iceberg code blocks, followed by regular $I{k}$9 syndrome extraction on each of the lower-level $k$0 blocks.” For the implemented $k$1 code, “the resulting circuit, shown in Fig. 1d, uses only 18 physical ancilla qubits, and has depth $k$2.”

The supplementary proposition gives the formal behavior of this QEC cycle:

1. If the QEC cycle contains no fault, it takes an input with a generalized weight-1 or weight-0 error to an error-free output, and halts the computation in the case of a generalized weight-2 input.
2. If the QEC cycle contains a single internal fault, it takes an error-free input to an output with error of generalized weight at most 1; for an input with a generalized weight-1 error, it either outputs generalized weight-1 or passes flags to the next cycle that cause a halt.
3. If the QEC cycle contains at two internal faults, it takes an error-free input to an output of at most generalized weight-2, or halts.

For logical gates, the paper introduces encoded $k$3, encoded $k$4, and logical FANOUT. The inter-block $k$5 and $k$6 gadgets are described as partially fault-tolerant, whereas FANOUT is singled out as fully fault-tolerant “even to all single weight-2 gate errors,” while using “a number of gates (four) that does not scale with the size of the code blocks.” FANOUT is used directly for logical GHZ-state preparation.

Postselection is integral to all of these protocols. The operational rule is to measure stabilizers and flags, discard shots with nontrivial flags or uncorrectable syndromes, and retain only shots consistent with correctable patterns. The paper explicitly addresses a common objection: “Postselecting out detectable, but not correctable, weight-$k$7 faults in even-distance codes should not be misconstrued as a non-scalable technique, since, below threshold, both the error rate and the postselection overheads are exponentially suppressed with increasing code distance” (Dasu et al., 25 Feb 2026).

6. Experimental realization and benchmarked performance

The experiments were performed on “the 98-qubit Quantinuum Helios trapped-ion quantum processor.” Within that platform, the two-level concatenated iceberg code appears primarily in state preparation and measurement, QEC-cycle benchmarking, and GHZ preparation.

For SPAM, the $k$8 code encodes 48 logical qubits. In one main experiment, “the $k$9 SPAM experiment recorded no logical errors,” with “an upper bound … on the SPAM infidelity per logical qubit of $d=2$0.”

For QEC-cycle benchmarking, the $d=2$1 48-logical-qubit cycle had average infidelity per logical qubit “upper-bounded by $d=2$2 with no logical errors recorded in five thousand shots in each basis,” at an acceptance rate of “$d=2$3 when postselecting out uncorrectable errors.” The paper compares this to the physical depth-1 linear memory error of “$d=2$4,” making this one of the clearest beyond-break-even comparisons for the concatenated code.

The section-level acceptance figures for the $d=2$5 QEC cycle are also reported explicitly. Leakage acceptance is approximately $d=2$6 in the $d=2$7 basis and $d=2$8 in the $d=2$9 basis; preacceptance is approximately $n = k + 2$0 and $n = k + 2$1; QEC acceptance is approximately $n = k + 2$2 and $n = k + 2$3; and there were 0 errors among 708 and 958 accepted shots, respectively.

For GHZ preparation on 48 logical qubits, the paper reports no logical errors for $n = k + 2$4 over several thousand shots. In the tabulated results, the $n = k + 2$5-basis instance has leakage acceptance $n = k + 2$6, overall accept rate $n = k + 2$7, 790 accepted shots, and 0 errors; the $n = k + 2$8-basis instance has leakage acceptance $n = k + 2$9, overall accept rate $S_{X/Z} = \prod_{j=0}^{n-1}(X/Z)_j,$0, 1233 accepted shots, and 0 errors. The GHZ routine also uses a specific postselection rule: “If the two $S_{X/Z} = \prod_{j=0}^{n-1}(X/Z)_j,$1 measurements differ by a logical operator, we postselect.” The paper states that by postselecting in the presence of two faults, the preparation has logical error rate $S_{X/Z} = \prod_{j=0}^{n-1}(X/Z)_j,$2, while correcting a single error anywhere in the preparation yields postselection probability $S_{X/Z} = \prod_{j=0}^{n-1}(X/Z)_j,$3.

The paper also gives a compact illustration of how concatenation affects acceptance. For the smaller $S_{X/Z} = \prod_{j=0}^{n-1}(X/Z)_j,$4 code, “increasing the distance from 2 to 4 by concatenation significantly boosts the AR (averaged over both initial states) from $S_{X/Z} = \prod_{j=0}^{n-1}(X/Z)_j,$5 to $S_{X/Z} = \prod_{j=0}^{n-1}(X/Z)_j,$6,” while the infidelities “$S_{X/Z} = \prod_{j=0}^{n-1}(X/Z)_j,$7 and $S_{X/Z} = \prod_{j=0}^{n-1}(X/Z)_j,$8 for distances $S_{X/Z} = \prod_{j=0}^{n-1}(X/Z)_j,$9 and $k$00 respectively, are indistinguishable.” The paper summarizes this trend as follows: “increasing the distance via concatenation already enhances acceptance rates without degrading fidelity.”

The scope of the two-level code within the broader study is also delimited explicitly. It is directly used for SPAM, QEC-cycle benchmarking, and GHZ preparation. It is not the code used for the reported logical gate benchmarking, which is performed on $k$01 blocks, and it is not the code used for the three-dimensional $k$02-model simulation, which uses a single $k$03 distance-2 iceberg block rather than the concatenated construction. This suggests that, within the reported experiments, two-level iceberg codes function primarily as the distance-4 vehicle for high-rate logical memory, preparation, readout, and multipartite entanglement benchmarks (Dasu et al., 25 Feb 2026).