Smallest Interesting Colour Code

• Smallest Interesting Colour Code is a [[8,3,2]] quantum error-detecting code defined on a cube that encodes three logical qubits and supports a transversal CCZ gate.
• It employs a stabilizer structure with global X/Z operators and weight-4 generators, providing a clear framework for fault-tolerant error detection.
• Experimental studies demonstrate its ability to reduce error rates substantially through post-selection, making it ideal for early fault-tolerant quantum architectures.

Searching arXiv for papers explicitly using or defining “Smallest Interesting Colour Code,” plus closely related color-code architecture and verification papers. The Smallest Interesting Colour Code is the $[[8,3,2]]$ colour code: a distance-two quantum error-detecting code on eight physical qubits that encodes three logical qubits and is usually presented on the vertices of a cube. The designation “smallest interesting” is tied to a specific fault-tolerant property rather than to minimal size alone: the code is the smallest member of a class of quasi-transversal codes whose logical three-qubit $CCZ$ gate is realized transversally by single-qubit non-Clifford gates, while still supporting a nontrivial multi-logical-qubit structure within one block (Garvie et al., 2017). In later experimental and architectural work, the same phrase is used for the $[[8,3,2]]$ code because it is small enough for near-term hardware yet already supports a transversal logical $ccz$, logical permutations implementing Clifford structure, and low-overhead error-detecting protocols (Wang et al., 2023).

1. Definition and nomenclature

In the literature that uses the phrase explicitly, the Smallest Interesting Colour Code is the $[[8,3,2]]$ colour code. The parameters mean that the code uses $n=8$ physical qubits, encodes $k=3$ logical qubits, and has distance $d=2$. Distance $2$ implies that any single-qubit error is detectable, but not generally correctable, so the code is used as an error-detecting code rather than as a fully single-error-correcting code (Garvie et al., 2017).

The qualifier “interesting” is operational. The code is selected in fault-tolerance settings because it encodes three logical qubits in one block and supports a transversal logical $ccz$. That combination is already sufficient for compact non-Clifford fault-tolerant demonstrations, including one-bit addition on trapped-ion hardware, and for early fault-tolerant architectural proposals that alternate between $CCZ$0 and $CCZ$1 colour-code blocks (Wang et al., 2023).

This naming convention is not a universal claim about all colour-code formalisms. A plausible implication is that “smallest” is criterion-dependent: in other parts of the colour-code literature, the smallest explicitly identified 3D qudit colour code is the 15-qudit tetrahedral 3D color code, while the smallest nontrivial triangular planar colour code is the distance-3, 7-qubit code (Watson et al., 2015, Sahay et al., 2021). The phrase “Smallest Interesting Colour Code,” however, is used specifically for the $CCZ$2 cube code in the fault-tolerance literature (Garvie et al., 2017).

2. Stabilizer, logical, and geometric structure

Geometrically, the code is presented as a cube, with one physical qubit at each vertex. In the experimental presentation, the code has five independent stabilizer generators. One convenient generating set is

$CCZ$3

$CCZ$4

together with three weight-4 $CCZ$5-type generators

$CCZ$6

Since $CCZ$7 and there are five independent stabilizers, the code encodes three logical qubits (Wang et al., 2023).

A standard choice of logical Pauli operators is

$CCZ$8

$CCZ$9

$[[8,3,2]]$0

In the cube picture, the logical $[[8,3,2]]$1 operators are supported on faces and the logical $[[8,3,2]]$2 operators on edges, so the code’s distance-two character is visible directly in the existence of weight-2 logical $[[8,3,2]]$3 representatives (Wang et al., 2023).

The encoded computational basis is explicitly known. For example,

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

$[[8,3,2]]$5

and the remaining basis states are likewise GHZ-like superpositions determined by the logical-$[[8,3,2]]$6 structure (Garvie et al., 2017). This basis makes the code space concrete as an 8-dimensional subspace of the 8-qubit Hilbert space.

3. Quasi-transversality and logical gate structure

The code’s defining non-Clifford feature is its logical $[[8,3,2]]$7. In the verification literature, the physical implementation is written as

$[[8,3,2]]$8

that is, an alternating pattern of $[[8,3,2]]$9 and $ccz$0 gates on the eight physical qubits. This acts as a logical $ccz$1 on the encoded code words (Garvie et al., 2017). The existence of this transversal non-Clifford gate is the main reason the code is considered “interesting.”

The code also supports nontrivial Clifford structure. In the experimental one-bit-adder implementation, the logical $ccz$2 can be implemented by permuting or relabelling the physical qubits. The paper describes the induced logical action as

$ccz$3

with the other logical operators unchanged, i.e. exactly the action of a $ccz$4 between two logical qubits (Wang et al., 2023).

The logical Hadamard is more subtle. The set

$ccz$5

is stated to be universal, but the code does not support transversal logical $ccz$6 in the same direct way as it supports transversal $ccz$7. This motivates later architectures in which logical states are teleported between the $ccz$8 code and the $ccz$9 colour code, using the former for transversal $[[8,3,2]]$0 and the latter for transversal $[[8,3,2]]$1 (Wang et al., 2023, Nelson et al., 27 Jul 2025).

A recurring misconception is to treat the code as a miniature version of a conventional distance-three topological memory. The literature does not do that. Instead, the code is valued because it combines error detection, multiple logical qubits in a single block, and a transversal non-Clifford gate, which is a different optimization point from that of scalable surface-code-like memories (Garvie et al., 2017).

4. Formal verification in the ZX-calculus

A substantial part of the code’s early literature concerns formal verification rather than discovery. The code was analyzed in the ZX-calculus and in the theorem prover Quantomatic, where the encoder, decoder, logical Paulis, encoded $[[8,3,2]]$2, and logical $[[8,3,2]]$3 were verified graphically (Garvie et al., 2017).

The encoder is constructed by starting from an 8-qubit GHZ state and composing the logical-$[[8,3,2]]$4 action associated with the three logical input qubits. The decoder is the adjoint of the encoder. One of the basic machine-checked results is

$[[8,3,2]]$5

i.e. encoding followed by decoding is the identity on the three logical qubits. In the reported Quantomatic proof, this required 66 rewrite steps and took approximately 5 seconds of real time. The encoder was also shown to be a unitary embedding, with an automated normalization stage of 28 rewrite steps taking approximately 2 seconds (Garvie et al., 2017).

The logical Pauli operators were verified in strong form, for example

$[[8,3,2]]$6

and analogous identities for the other logical $[[8,3,2]]$7 and $[[8,3,2]]$8 operators. The encoded $[[8,3,2]]$9 was also established in the weak fault-tolerance form

$n=8$0

with the reported proof requiring 75 steps (Garvie et al., 2017).

The logical $n=8$1 is the place where the formal-method limitations are most visible. Rather than proving the full operator identity directly, the verification proceeds by checking the action of the transversal $n=8$2 pattern on a basis of code words. The paper reports that each of the eight basis-state cases required roughly 80–90 steps and that the strategy “did not appear amenable to automation” (Garvie et al., 2017). This has become a standard example of the gap between automated rewriting in angle-free ZX fragments and non-Clifford verification in the full multi-qubit Clifford+$n=8$3 setting.

5. Experimental realization and early fault-tolerant architecture

The code was used to implement fault-tolerant one-bit addition on the Quantinuum H1-1 quantum computer. The motivation was explicit: “To encode the three logical qubits necessary for one-bit addition and gain access to a transversal $n=8$4, we select the $n=8$5 colour code.” The implementation reduces the number of error-prone two-qubit gates and measurements to 36, namely 24 CNOTs and 12 measurements (Wang et al., 2023).

The experiment uses error detection with post-selection, not full active correction. This follows directly from the code distance $n=8$6. The paper states that the protocol is “fault-tolerant with post-selection/error detection,” and reports a moderate post-selection overhead of about 10\% (Wang et al., 2023). The arithmetic error criterion is

$n=8$7

for measured output register values $n=8$8.

The reported arithmetic error rates on device were

$n=8$9

for the non-fault-tolerant circuit and

$k=3$0

for the fault-tolerant circuit. The abstract also summarizes these as approximately

$k=3$1

respectively (Wang et al., 2023). The result is therefore not merely formal: on the stated hardware and task, the encoded $k=3$2 protocol reduced the arithmetic error rate by about an order of magnitude.

Later work embeds the code in an early fault-tolerant quantum computing architecture together with the $k=3$3 colour code. In that proposal, state teleportations between the two codes allow use of the respective transversal $k=3$4 and $k=3$5 gates, and the relevant optimization target becomes explicit: minimizing the number of logical quantum teleportation operations, not the number of logical quantum non-Clifford gates (Nelson et al., 27 Jul 2025).

Code	Parameters	Role in the architecture
2D colour code	$k=3$6	Transversal $k=3$7
3D colour code	$k=3$8	Transversal $k=3$9

For $d=2$0 computational logical qubits, the same architecture gives the minimum physical-qubit count

$d=2$1

It also gives a fully parallel ancilla strategy with

$d=2$2

and a middle-ground strategy with

$d=2$3

These formulas make clear that the Smallest Interesting Colour Code is now used not only as a pedagogical example, but as a concrete primitive in EFTQC resource models (Nelson et al., 27 Jul 2025).

6. Scope, limitations, and broader context

The code’s limitations are intrinsic to its parameters. Because it is a $d=2$4 code, it is an error-detecting code, not a fully error-correcting one. Experimental protocols based on it therefore rely on post-selection, and architectural proposals based on it are explicitly framed as early fault-tolerant rather than utility-scale schemes (Wang et al., 2023, Nelson et al., 27 Jul 2025).

It is also not the only small code called “interesting” in adjacent colour-code research. In planar decoding studies, the smallest nontrivial triangular colour code is the distance-3 code with $d=2$5 qubits, while the smallest sizes that already show the full decoding subtleties of the Möbius-strip decoder are around $d=2$6 or $d=2$7 (Sahay et al., 2021). In qudit colour-code work, the smallest explicitly identified 3D example is the 15-qudit tetrahedral 3D color code, which is the first small instance supporting the paper’s non-Clifford transversal phenomena in that formalism (Watson et al., 2015). This suggests that “smallest interesting” is a context-sensitive label rather than a universal minimization theorem.

The specific historical role of the Smallest Interesting Colour Code is therefore narrower and more precise. It names the $d=2$8 cube code because that code is the smallest one in its line of work that already exhibits the combination of features needed for nontrivial fault-tolerant computation: three encoded logical qubits, explicit logical Pauli geometry, a transversal logical $d=2$9, logical Clifford structure via permutations, and experimentally viable error-detecting protocols (Garvie et al., 2017, Wang et al., 2023). Within that scope, it remains a canonical compact platform for studying non-Clifford fault tolerance, graphical verification, and EFTQC architecture.