Four-Qubit Iceberg Code Overview

• The Four-Qubit Iceberg Code is a compact [[4,2,2]] stabilizer code that encodes 2 logical qubits into 4 physical qubits and detects any single-qubit error using two global parity operators.
• It employs weight-2 logical operators and flexible logical representations to enable cost-effective, hardware-efficient compilation for trapped-ion systems.
• It plays a key role in magic-state distillation and concatenated error-detecting architectures, optimizing overhead and supporting fault-tolerant postselection protocols.

The Four-Qubit Iceberg Code is the four-physical-qubit, two-logical-qubit member of the Iceberg family of quantum error-detecting stabilizer codes, obtained by specializing $[[k+2,k,2]]$ to $k=2$, equivalently $[[n,n-2,2]]$ at $n=4$, or $[[2m,2m-2,2]]$ at $m=2$. In all of these parameterizations the code is $[[4,2,2]]$: it encodes $2$ logical qubits into $4$ physical qubits, has distance $2$, detects any single-qubit error, and is used primarily in detection-and-discard protocols rather than full single-error correction (Self et al., 2022, Mazzetti et al., 10 Apr 2026, Riffel et al., 14 Apr 2026). Earlier literature studied the same $k=2$0 stabilizer code without the “Iceberg” name; in particular, the magic-state distillation paper on $k=2$1 explicitly does not mention “Iceberg,” while later work identifies the four-qubit Iceberg code directly with the $k=2$2 code (Meier et al., 2012, Reichardt et al., 14 May 2026).

1. Terminology and identification

The terminology “Iceberg code” originates in trapped-ion-oriented work that defines a family of stabilizer codes with parameters $k=2$3 for even $k=2$4, labels two special qubits as $k=2$5 and $k=2$6, and emphasizes that many logical operators have support on only two physical qubits (Self et al., 2022). Within that family, the four-qubit case is the smallest nontrivial instance, since $k=2$7 gives $k=2$8 (Jin et al., 29 Apr 2025).

The same four-qubit object appears in older and parallel literature under other names. In the magic-state distillation literature it is the four-qubit error-detecting code $k=2$9, a $[[n,n-2,2]]$0 stabilizer code with stabilizers $[[n,n-2,2]]$1 and $[[n,n-2,2]]$2, used operationally as an ordinary stabilizer code rather than as a subsystem code (Meier et al., 2012). In the “Fire and ice” architecture it is again the $[[n,n-2,2]]$3 code, now explicitly called the “four-qubit Iceberg code,” and used as the inner code of larger concatenated CSS constructions (Reichardt et al., 14 May 2026).

The nomenclature is not universal across four-qubit coding theory. The classification paper on four-qubit pure codes does not use the term “Iceberg code,” but it proves that every four-qubit pure code is local-unitarily equivalent to a subspace of the unique $[[n,n-2,2]]$4 code, realized as the simultaneous $[[n,n-2,2]]$5 eigenspace of $[[n,n-2,2]]$6 and $[[n,n-2,2]]$7 (Tan, 2 Jul 2025). By contrast, a four-qubit deletion-correcting code and a four-qubit amplitude-damping code are different constructions whose papers explicitly do not use the term “Iceberg code” (&&&10&&&, Mao et al., 2024).

2. Stabilizer definition, logical structure, and basis states

In the Iceberg presentation, the four physical qubits are labeled $[[n,n-2,2]]$8, where $[[n,n-2,2]]$9 and $n=4$0 are “top” and “bottom” qubits. The stabilizer generators are the two global parity operators

$n=4$1

Because there are $n=4$2 physical qubits and $n=4$3 independent stabilizer generators, the codespace has dimension $n=4$4, so the code indeed encodes $n=4$5 logical qubits (Jin et al., 29 Apr 2025).

A standard logical Pauli choice in the Iceberg family is

$n=4$6

so that, explicitly,

$n=4$7

The literature also emphasizes stabilizer-equivalent representative freedom. For the four-qubit case, one may equally use

$n=4$8

and this flexibility is operationally important because different representatives correspond to different hardware-efficient gate realizations (Jin et al., 29 Apr 2025). In the earlier $n=4$9 notation, one valid logical choice is

$[[2m,2m-2,2]]$0

$[[2m,2m-2,2]]$1

again illustrating that the same $[[2m,2m-2,2]]$2 code admits multiple logical coordinate systems (Meier et al., 2012).

A convenient encoded computational basis, in the qubit ordering $[[2m,2m-2,2]]$3, is

$[[2m,2m-2,2]]$4

$[[2m,2m-2,2]]$5

$[[2m,2m-2,2]]$6

$[[2m,2m-2,2]]$7

up to relabeling conventions for the physical qubit order (Jin et al., 29 Apr 2025). The all-logical-zero state of the general Iceberg family is an $[[2m,2m-2,2]]$8-qubit GHZ state; for $[[2m,2m-2,2]]$9,

$m=2$0

which matches the first basis vector above (Self et al., 2022).

From a structural viewpoint, the code is the simultaneous $m=2$1 eigenspace of $m=2$2 and $m=2$3. The classification result that the unique $m=2$4 code has basis

$m=2$5

places the four-qubit Iceberg code within a canonical four-qubit pure-code normal form (Tan, 2 Jul 2025).

3. Symmetry, transversal structure, and encoded operations

A central symmetry of the $m=2$6 code is exchange of $m=2$7 and $m=2$8. In the $m=2$9 formulation, this implies that $[[4,2,2]]$0 is a valid encoded gate, and, for the logical Pauli choice used there, it acts as a logical Hadamard on both encoded qubits followed, or equivalently preceded, by a logical SWAP: $[[4,2,2]]$1 This transversal Hadamard property is the key ingredient behind the code’s use in Hadamard-eigenstate distillation (Meier et al., 2012).

The later Iceberg literature emphasizes a broader family-wide gate structure. Logical single-qubit $[[4,2,2]]$2-rotations are implemented as physical two-qubit rotations,

$[[4,2,2]]$3

and many multi-logical operators also have two-body physical representatives. In particular, for the family one has identities such as

$[[4,2,2]]$4

For $[[4,2,2]]$5, these are simply the two-logical-qubit products of the four-qubit code (Self et al., 2022). The same hardware orientation appears in the QAOA co-compilation work, which uses

$[[4,2,2]]$6

to reduce circuit depth by allowing logical mixer rotations to be routed through either the top or bottom hub qubit (Jin et al., 29 Apr 2025).

This low-weight logical structure directly affects compilation. In the four-qubit-patch compiler, targeted $[[4,2,2]]$7 is expensive—$[[4,2,2]]$8 one-qubit gates and $[[4,2,2]]$9 two-qubit gates, at depth $2$0—whereas the patch-wise operation $2$1 costs only $2$2 one-qubit gates at depth $2$3. Likewise, for logical CNOT the compiler distinguishes intra-patch, inter-patch, and transversal implementations with costs $2$4 two-qubit gates, depth $2$5, $2$6 two-qubit gates, depth $2$7, and $2$8 two-qubit gates, depth $2$9, respectively (Mazzetti et al., 10 Apr 2026). This asymmetry makes Hadamard commutation, gate merging, and qubit-pair assignment central to practical use of the code.

4. Error-detecting behavior and fault-tolerant gadgets

The four-qubit Iceberg code has distance $4$0. It can detect any single-qubit error, but cannot in general correct an arbitrary single-qubit error, because distance $4$1 implies detect-and-discard rather than full correction-and-continue (Jin et al., 29 Apr 2025). Concretely, any single-qubit Pauli error anticommutes with at least one stabilizer: a $4$2 error anticommutes with $4$3, an $4$4 error anticommutes with $4$5, and a $4$6 error anticommutes with both (Jin et al., 29 Apr 2025). Conversely, some weight-2 operators commute with both stabilizers and act as logical operators, which is exactly why the code distance is $4$7 rather than $4$8 (Meier et al., 2012).

The operational mode is therefore postselection. Error detection is performed by measuring the global stabilizers $4$9 and $2$0, or by running a gadget that extracts their syndromes onto ancillas; on detection of an error, the circuit execution is discarded (Jin et al., 29 Apr 2025). In the trapped-ion implementation, the initialization and syndrome-measurement circuits are fault tolerant in the sense that there is no single component whose failure produces an undetectable logical error. The syndrome-measurement circuit uses two ancillas to separately read out the two stabilizers, arranged so that the ancillas act as flag qubits to each other. At final readout, $2$1 can be reconstructed from destructive computational-basis measurement of all physical qubits, while $2$2 is extracted immediately before final readout (Self et al., 2022).

Later work refined these gadgets. For the $2$3 code, the new initialization, syndrome, and final-measurement gadgets reduce two-qubit depth from

$2$4

The improved syndrome gadget is valid only when $2$5 is a multiple of $2$6, and the four-qubit code is the smallest case satisfying that condition (Jin et al., 29 Apr 2025).

These features explain both the attractiveness and the limitation of the code. It satisfies the distance-2 fault-tolerance criterion used in the Iceberg literature—“no single component failure results in an undetectable logical error”—yet it remains an error-detecting code, so rejection rates can dominate if the physical circuit or the ancilla factory is poorly compiled or too deep (Jin et al., 29 Apr 2025, Reichardt et al., 14 May 2026).

5. Role in magic-state distillation

Before the “Iceberg” nomenclature, the four-qubit $2$7 code was used as $2$8 in a 10-to-2 routine for distilling the $2$9 eigenstate of Hadamard,

$k=2$00

Each round uses $k=2$01 input $k=2$02-type resource states: $k=2$03 data states to be distilled and $k=2$04 gate states consumed to implement four controlled-$k=2$05 gates (Meier et al., 2012).

Operationally, the protocol encodes two noisy $k=2$06-type magic states into $k=2$07, performs an encoded measurement of $k=2$08, decodes and measures the syndrome, and accepts only if both the encoded measurement and the syndrome measurement indicate no error (Meier et al., 2012). The transversal Hadamard property of the code, together with a circuit simplification using the logical SWAP relation, reduces the encoded measurement to four physical controlled-$k=2$09 gates rather than a larger naïve construction (Meier et al., 2012).

Under the Hadamard-basis-twirled noise model,

$k=2$10

with stochastic $k=2$11 error probability $k=2$12, the exact acceptance probability is

$k=2$13

the marginal undetected-error probability on one output is

$k=2$14

and the conditional marginal output error rate is

$k=2$15

The threshold defined by $k=2$16 is

$k=2$17

The paper explicitly contrasts this with the 15-to-1 Bravyi–Kitaev routine: the four-qubit-code routine has lower threshold but lower overhead, gives $k=2$18 rather than $k=2$19, and can reduce overhead by up to about an order of magnitude in practical combined-distillation regimes (Meier et al., 2012).

This distillation application is historically important because it shows the four-qubit code in a role that already exhibits the later Iceberg themes: strong $k=2$20 symmetry, transversal Hadamard structure, single-fault detectability, and aggressive overhead optimization through postselection.

6. Concatenation, selective filtering, and higher-distance descendants

The four-qubit Iceberg code is not only a stand-alone detector; it is also an inner code in concatenated high-rate architectures. In the “Fire and ice” construction, if the outer code is an $k=2$21 ququad code, then concatenation with the four-qubit Iceberg code gives

$k=2$22

This is the central structural formula behind a family of compact self-dual CSS codes (Reichardt et al., 14 May 2026). The flagship example takes the five-qubit Laflamme code $k=2$23, maps it to a $k=2$24 CSS code, and concatenates with the four-qubit Iceberg code to obtain a $k=2$25 code (Reichardt et al., 14 May 2026).

The architectural motivation is explicit. Because a four-qubit Iceberg block encodes two logical qubits, ququad outer-code symbols are realized naturally as single inner blocks. This enables efficient encoded-state preparation through what the paper calls the “paired support” property, while preserving CSS structure and doubling distance under concatenation (Reichardt et al., 14 May 2026). The resulting family includes $k=2$26 and $k=2$27, supports transversal Clifford structure, and uses selective filtering rather than full circuit-level fault tolerance.

The same paper is equally explicit about the limitation: the full scheme is “explicitly not fault tolerant,” and low-order malignant faults can produce undetected logical errors in ancilla-preparation networks (Reichardt et al., 14 May 2026). For even-distance codes with postselection it states

$k=2$28

where $k=2$29 is logical error conditioned on acceptance and $k=2$30 is rejection probability (Reichardt et al., 14 May 2026). For the bare $k=2$31 Iceberg code, the rejection overhead is particularly severe: at $k=2$32,

$k=2$33

and the ratio is even larger at smaller $k=2$34, which is why the code is mainly valuable there as an inner code rather than as the final computational code (Reichardt et al., 14 May 2026).

The Helios iceberg-QED/QEC work makes the same point in a different language. It defines $k=2$35 as the $k=2$36 iceberg family and shows that

$k=2$37

is the concatenated distance-4 descendant of the four-qubit block (Dasu et al., 25 Feb 2026). For 4 logical qubits, increasing distance from 2 to 4 by concatenation raises average acceptance rate per cycle from

$k=2$38

while the corresponding infidelities,

$k=2$39

are statistically indistinguishable (Dasu et al., 25 Feb 2026). A plausible implication is that, in practical regimes, the four-qubit code’s most scalable role is as a primitive layer in higher-distance postselected architectures.

7. Compilation, hardware demonstrations, and practical scope

The Iceberg framework is tailored to trapped-ion hardware with all-to-all connectivity and native high-fidelity two-qubit entangling gates. The original Iceberg paper demonstrated protection of circuits of $k=2$40 logical qubits with up to $k=2$41 layers, saturated the logical quantum volume of $k=2$42, and argued that increasing the frequency of syndrome measurements within the circuit positively affects performance (Self et al., 2022). Although these are not four-qubit-only experiments, they establish the operational context in which the four-qubit code functions as the minimal building block.

The co-compilation work sharpened this hardware perspective by treating the entire $k=2$43 Iceberg family as a flexible compilation object and specializing many of its claims to the four-qubit case. It showed that the fault-tolerant gadgets are not rigid, that their implicit qubit order can be permuted without breaking fault tolerance, and that co-optimizing QAOA circuits with Iceberg gadgets improves success probability from $k=2$44 to $k=2$45 and post-selection rate from $k=2$46 to $k=2$47 at $k=2$48 algorithmic qubits, while enabling better-than-unencoded performance up to $k=2$49 algorithmic qubits (Jin et al., 29 Apr 2025). In that work, the four-qubit Iceberg code is presented as the smallest member that already contains the essential ingredients of the framework: two global stabilizers, weight-2 logical operators, ancilla-assisted syndrome extraction, postselection, and representative freedom.

Subsequent experimental work demonstrated “above break-even” error detection with the Iceberg family on trapped-ion hardware. For Bell-state circuits, which are especially natural for a two-logical-qubit $k=2$50 block, encoded postselected fidelities exceeded baseline in several runs; for the “Transversal-$k=2$51 Bell State” circuit, the non-fault-tolerant encoded implementation reached $k=2$52 versus $k=2$53 in one run, while the fault-tolerant version reached $k=2$54 versus $k=2$55 in another, at the cost of substantial detected-error rates (Riffel et al., 14 Apr 2026). The same paper stresses that the practical success of small Iceberg codes depends not only on encoding but also on code-aware compilation, especially exploiting cheap transversal $k=2$56 where possible (Riffel et al., 14 Apr 2026).

That compilation problem was then addressed directly for the four-qubit Iceberg patch. Across $k=2$57 benchmark circuits, logical compilation for $k=2$58 patches reduced circuit depth by $k=2$59, one-qubit and two-qubit gate counts by up to $k=2$60 and $k=2$61, improved total variation distance by $k=2$62, and improved logical selection rate by an average of $k=2$63 relative to naïve compilation (Mazzetti et al., 10 Apr 2026). In that framework, the central optimization problem is pairing program qubits into two-logical-qubit patches so as to expose cheap patch-wise operations such as $k=2$64, $k=2$65, and $k=2$66, while also allowing inter-patch or transversal implementations when they are cheaper (Mazzetti et al., 10 Apr 2026).

Taken together, these results delimit the practical scope of the four-qubit Iceberg code. It is extremely small, structurally symmetric, and compilation-sensitive; it supports unusually compact logical operations and efficient postselected filtering; but by itself it is only a distance-2 detector, so rejection overhead can be high and long computations typically motivate concatenation or larger descendants (Self et al., 2022, Reichardt et al., 14 May 2026, Mazzetti et al., 10 Apr 2026). In that sense, the Four-Qubit Iceberg Code is best understood both as a concrete $k=2$67 stabilizer code and as the canonical elementary block of a wider high-rate, postselected, trapped-ion-oriented coding architecture.