Color Codes

Colour a honeycomb so that no two touching hexagons share a colour, drop a qubit on every corner, and hang two check operators on each hexagon — one built from Pauli $X$ , one from Pauli $Z$ , both on the very same six qubits. That single design choice is the whole of the color code, and it buys something the surface code cannot have. Because $X_f$ and $Z_f$ live on identical supports, the entire lattice is symmetric under exchanging $X\leftrightarrow Z$ : apply a Hadamard to every qubit and the stabilizer group maps to itself, so a transversal Hadamard is a logical Hadamard. Add a checkerboard of phase gates and a bitwise CNOT between two blocks and the complete two-dimensional Clifford group becomes transversal — cheap, local, fault-tolerant logic with no lattice surgery and no code deformation. The price is paid in two currencies. The stabilizers are heavier (weight-six hexagons versus the surface code's weight-four checks), and the syndromes are stranger: excitations carry a colour charge obeying the fusion rule red × green = blue, so a single error lights three differently-coloured plaquettes at once and cannot be decoded by naïvely pairing defects. Underneath, a fixed local Clifford circuit reveals that a 2D color code is nothing but two copies of the toric code in disguise, which fixes its parameters ( $k = 4g$ logical qubits on a genus- $g$ surface) and its optimal threshold (about 10.9%) while preserving the transversal-gate advantage. Introduced by Héctor Bombín and Miguel Ángel Martín-Delgado in 2006, color codes now sit at the centre of fault-tolerant architecture, and in 2024 they graduated from the blackboard to real trapped-ion and superconducting processors.

Key takeaways

A color code is a topological CSS stabilizer code on a three-colorable, trivalent tiling: qubits sit on vertices, and every face $f$ carries both $X_f=\prod_{v\in f}X_v$ and $Z_f=\prod_{v\in f}Z_v$ on the same qubits.
Three-colorability plus trivalency forces any two faces to overlap on an even number of qubits, so $[X_f,Z_{f'}]=0$ automatically — the CSS commutation condition is built into the geometry.
Because $X_f$ and $Z_f$ share support, bitwise Hadamard swaps the stabilizers among themselves: the 2D color code implements the whole Clifford group ( $H$ , $S$ , CNOT) transversally, which the surface code cannot.
A local Clifford circuit maps the 2D color code onto two decoupled copies of the toric code; this duality fixes $k=4g$ logical qubits on a genus- $g$ surface (twice the toric code) and an optimal code-capacity threshold near 10.9%.
Excitations carry a conserved colour charge with fusion red × green = blue, so a single error creates a colour-neutral triple of defects and decoding cannot reduce to independent minimum-weight matching.
In 3D the construction gains a transversal non-Clifford gate ( $T$ or $CCZ$ ) and single-shot error correction, and combining 2D and 3D blocks (dimension jump) reaches universality without magic-state distillation.
Key idea: put a qubit on every vertex of a three-colorable trivalent lattice and assign both $X_f$ and $Z_f$ to each face; three-colorability guarantees CSS commutation, and the $X$ / $Z$ symmetry on identical supports buys transversal Hadamard and phase gates — the entire 2D Clifford group — at the cost of weight-six stabilizers and colour-charged, harder-to-decode syndromes.

Where this lives today

For most of two decades the color code was prized on paper — cheaper Cliffords, richer structure — but held back in the lab by its weight-six checks and awkward decoding. That changed in 2024. Google Quantum AI ran color-code logical qubits on a superconducting processor, operating distance-3 and distance-5 codes and demonstrating transversal logical Clifford gates directly, the exact advantage the code was designed for. On the trapped-ion side, Quantinuum's processors have realized the $[[7,1,3]]$ Steane color code with real-time syndrome extraction and fault-tolerant logic, exploiting all-to-all connectivity to measure the weight-4 checks cleanly. The decoding bottleneck that long defined the code is now an active engineering frontier: the restriction and projection decoders, union-find, the Möbius matching approach, and neural-network decoders all confront the colour-charge fusion structure head-on, and the search for an efficient decoder that approaches the ~10.9% optimal threshold is one of the open problems in the field. In 3D, the single-shot property — correcting errors from a single noisy round of syndrome extraction, without the surface code's $O(d)$ repeated measurements — keeps color codes central to proposals that aim to cut the time overhead of fault tolerance. The through-line is transversality: whenever a logical algorithm is Clifford-heavy, the color code's cheap $H$ and $S$ turn a multi-cycle surface-code operation into a single layer of local gates.

The physical picture

Start from the honeycomb. Colour each hexagon red, green, or blue so that neighbours never match, and place one qubit at every vertex. To each hexagon attach two operators on its six qubits, $X_f$ and $Z_f$ . Two touching hexagons share exactly one edge — two qubits — so an $X$ -type check and a $Z$ -type check overlap on an even number of qubits and commute even though $X$ and $Z$ anticommute pointwise. Three-colorability is precisely the bookkeeping that keeps every overlap even: same-coloured faces never touch (overlap zero), and different-coloured faces meet along whole shared edges (overlap two, four, …). The first figure makes the two structural facts one picture — even overlap, and three colours meeting at every vertex.

Because $X_f$ and $Z_f$ sit on identical qubits, the lattice looks unchanged under swapping $X\leftrightarrow Z$ . A bitwise Hadamard performs exactly that swap, so it maps the stabilizer group to itself and permutes the logical operators as $\bar X\leftrightarrow\bar Z$ — a transversal Hadamard is a logical Hadamard. The surface code cannot do this: its $X$ (star) and $Z$ (plaquette) checks live on different geometric objects, so bitwise $H$ does not preserve its stabilizer. That single asymmetry is the whole difference in Clifford cost between the two code families. The smallest instance of the whole story — seven qubits, three colours, distance three — is the famous Steane code, and the second figure shows it doing everything at once.

Figure

The smallest 2D color code: a distance-three triangle of 7 qubits and 3 weight-4 faces (parameters n = 7, k = 1, d = 3), which is exactly the Steane code. An X error on the central qubit anticommutes with all three Z-faces, lighting a red, green and blue defect whose colour charge multiplies to the vacuum, r × g × b = 1

The core equations

The code is defined by attaching two Pauli operators to every face of the tiling. Physical qubits sit at the vertices, and the stabilizer group is generated by all of these face operators at once.

S = \langle\, X_f,\ Z_f \;:\; f\in F \,\rangle, \qquad X_f=\prod_{v\in f}X_v,\ \ Z_f=\prod_{v\in f}Z_v \qquad (1)

where: $F$ — the set of faces (plaquettes) of the three-colorable trivalent lattice; $v\in f$ — the vertices (qubits) on the boundary of face $f$ ; $X_v,Z_v$ — Pauli $X$ and $Z$ on the qubit at vertex $v$ ; $S$ — the abelian stabilizer group whose $+1$ eigenspace is the code space. Read it as: each face carries both a bit-parity check $Z_f$ and a phase-parity check $X_f$ , supported on identical qubits — the structural fingerprint that separates color codes from every other topological code. For this to be a legitimate CSS stabilizer group, all generators must commute. The pointwise anticommutation of $X$ and $Z$ means an $X$ -face and a $Z$ -face commute exactly when they share an even number of qubits, and the geometry guarantees it.

[X_f, Z_{f'}] = 0 \quad\Longleftrightarrow\quad |f\cap f'|\ \text{is even for all }f,f' \qquad (2)

where: $|f\cap f'|$ — the number of qubits (vertices) shared by faces $f$ and $f'$ . Reading: two different-coloured faces meet along complete shared edges, each contributing two qubits; two same-coloured faces never touch, contributing zero. Every overlap is a sum of even pieces, so $(-1)^{|f\cap f'|}=+1$ and the checks commute — the derivation below makes this exact. Counting independent generators against the number of qubits gives the code's headline parameters. On a closed surface the Euler characteristic ties the logical count directly to the topology.

k = n - \operatorname{rank}(S) = 4g,\qquad [[n,k,d]]:\ d = \min_{\ell\,\in\,N(S)\setminus S} |\ell| \qquad (3)

where: $n$ — physical qubits (= number of vertices $V$ ); $k$ — logical qubits; $\operatorname{rank}(S)$ — number of independent stabilizer generators; $g$ — genus of the closed surface; $\ell$ — a logical string operator in the normalizer but outside the stabilizer; $|\ell|$ — its weight (support size); $d$ — code distance. Reading: a genus- $g$ color code encodes $4g$ logical qubits, exactly twice the toric code's $2g$ , and the distance is the length of the shortest non-contractible coloured string. The defining payoff is transversal Clifford logic. Bitwise Hadamard exchanges $X_f$ and $Z_f$ ; a checkerboard of phase gates fixes the stabilizer; and a bitwise CNOT couples two blocks — together the full 2D Clifford group.

\bar H = \bigotimes_v H_v:\ X_f\leftrightarrow Z_f,\qquad \bar S = \bigotimes_v S_v^{\pm 1},\qquad \overline{\mathrm{CNOT}}=\bigotimes_v \mathrm{CNOT}_{v^{(1)}\to v^{(2)}} \qquad (4)

where: $H_v$ — Hadamard on qubit $v$ , with $HXH=Z$ , $HZH=X$ ; $S_v^{\pm 1}$ — phase gate or its inverse, assigned by a two-colouring of the (bipartite) vertices, with $SXS^\dagger=Y$ ; the CNOT runs qubit-by-qubit between two identical blocks. Reading: every Clifford generator is a depth-one pattern of single- or two-qubit gates — no lattice surgery, no code deformation, and automatically fault-tolerant because each gate touches one qubit per block. Errors are excitations on the violated faces, and in a color code each excitation carries a colour label obeying a fusion rule. A single-qubit Pauli lights the three differently-coloured faces meeting at its vertex, so the created charge is colour-neutral.

r\times g \to b,\qquad r\times g\times b = 1 \qquad (5)

where: $r,g,b$ — red, green, blue excitation charges on violated faces; $1$ — the vacuum. Reading: defects are never produced in same-coloured pairs, so pairing like colours is the wrong decoding move — a correct decoder must respect the three-colour fusion algebra or first map to two surface codes. That mapping is the deep structural fact: a fixed finite-depth local Clifford circuit turns one 2D color code into two independent toric codes.

\mathcal U_{\mathrm{loc}}:\ \mathrm{ColorCode}_{2D}\ \cong\ \mathrm{ToricCode}\otimes\mathrm{ToricCode} \qquad (6)

where: $\mathcal U_{\mathrm{loc}}$ — a locally generated (finite-depth) Clifford unitary. Reading: everything known about surface-code thresholds, string tension, and logical failure transfers to the color code, which explains $k=4g$ (two copies of $2g$ ) and the shared optimal threshold — while the colour dressing keeps the Cliffords transversal.

Derivation ACounting the logical qubits on a closed surface

The goal is to prove that a color code on a closed genus- $g$ surface encodes exactly $k=4g$ logical qubits, using nothing but the combinatorics of a trivalent three-colored tiling and the Euler characteristic. We will count vertices, edges and faces, count the raw stabilizer generators, subtract the dependencies that three-colorability forces among them, and watch the vertex count cancel to leave a purely topological answer — twice the toric code, the first quantitative signature of the two-copy duality.

Step 1. Use trivalency. Each vertex meets exactly three edges and each edge has two endpoints, so summing degrees gives $3V=2E$ , hence $E=\tfrac32 V$ . Here $V=n$ is the number of physical qubits. Why: trivalency is one of the two defining lattice conditions, and it pins the edge count to the qubit count before topology enters.

Step 2. Impose the Euler characteristic of the closed surface, $V-E+F=2-2g$ , with $F$ the number of faces and $g$ the genus. Why: this is the only place the global topology of the surface enters the count — everything else is local.

Step 3. Solve for the face count. Substituting $E=\tfrac32 V$ gives $F = 2-2g - V + \tfrac32 V = 2-2g+\tfrac12 V$ . Why: we need $F$ because each face contributes stabilizer generators, so the logical count will be an expression in $V$ and $F$ .

Step 4. Count generators and their dependencies. Each face gives one $X_f$ and one $Z_f$ , so there are $2F$ raw generators. But three-colorability forces relations: because each vertex lies on exactly one face of each colour, the product of all red $X$ -faces equals the product of all green $X$ -faces equals the product of all blue $X$ -faces (each equals $\prod_v X_v$ ). That is two independent $X$ -type relations, and by the same argument two $Z$ -type relations, so $\operatorname{rank}(S)=2F-4$ . Why: the colour classes each cover every qubit exactly once, which is precisely why the colour-summed products coincide and drain four generators from the count.

Step 5. Assemble. With $k=V-\operatorname{rank}(S)$ and $F=2-2g+\tfrac12 V$ ,

k = V - (2F-4) = V - 2\!\left(2-2g+\tfrac12 V\right) + 4 = 4g.

The $V$ -terms cancel identically, leaving $k=4g$ . Why: the cancellation is the statement that logical information is topological, not local — adding qubits by refining the lattice never changes $k$ . *On the torus $g=1$ this gives $k=4$ , exactly two toric codes ( $2\times 2$ ); a concrete hexagonal torus with $V=18$ has $E=27$ , $F=9$ , $\operatorname{rank}(S)=14$ , and $k=18-14=4$ , confirming the formula.*

Go deeper · Derivation B · 1 minWhy transversal Hadamard is a logical Hadamard

Derivation BWhy transversal Hadamard is a logical Hadamard

The goal is to show that applying a Hadamard to every physical qubit implements a logical Hadamard on the encoded information, and to make explicit that this works only because $X_f$ and $Z_f$ share support — the property no surface code has. We conjugate a single face operator, then the whole group, then the logical operators, and see the $X\leftrightarrow Z$ symmetry of the lattice reappear as $\bar X\leftrightarrow\bar Z$ at the logical level. The same symmetry argument, extended, is what makes the entire 2D Clifford group transversal.

Step 1. Recall the single-qubit action $H X H=Z$ and $H Z H=X$ : Hadamard swaps $X$ and $Z$ on each qubit. Why: this pointwise swap is the seed; everything follows from lifting it to the whole block.

Step 2. Conjugate a face operator. Since $\bar H=\bigotimes_v H_v$ acts qubit-by-qubit and $X_f$ is a product of $X_v$ over the face,

\bar H\,X_f\,\bar H = \prod_{v\in f} H_v X_v H_v = \prod_{v\in f} Z_v = Z_f.

Why: because $X_f$ and $Z_f$ occupy the same vertices, the swap sends the genuine stabilizer $X_f$ to the genuine stabilizer $Z_f$ — a surface-code $X$ -star would instead land on a non-stabilizer, which is exactly why the trick fails there.

Step 3. Conclude for the group. Every $X_f\mapsto Z_f$ and every $Z_f\mapsto X_f$ , so $\bar H S\bar H=S$ : the code space is preserved. Why: a physical operation that fixes the stabilizer group is a valid logical operation, since it maps the code space to itself.

Step 4. Read the logical action. On the normalizer, $\bar H$ swaps the logical strings $\bar X\leftrightarrow\bar Z$ , which is precisely the logical Hadamard. Combined with the checkerboard phase gate $\bar S$ (whose $\pm Y$ signs cancel on every even-weight face) and the bitwise $\overline{\mathrm{CNOT}}$ between two blocks, the full Clifford group is transversal. Why: $H$ and $S$ generate all single-qubit Cliffords and CNOT adds entangling power, so these three transversal gates close the 2D Clifford group. *The conjugation relations $HXH=Z$ , $HZH=X$ , $SXS^\dagger=Y$ and $S^\dagger XS=-Y$ hold by direct matrix computation; the even weight of every face is what makes the $\pm Y$ phase-gate signs cancel.*

Go deeper · Derivation C · 2 minEven overlap and the colour charge of a single error

Derivation CEven overlap and the colour charge of a single error

The goal is to prove that a single-qubit $X$ error violates exactly the three $Z$ -faces meeting at its vertex — one of each colour — so that the created excitation is colour-neutral, $r\times g\times b=1$ , and to draw the decoding consequence that separates color codes from the surface code. We use trivalency to fix how many faces a vertex touches, anticommutation to identify which stabilizers flag the error, and three-colorability to assign the colours.

Step 1. Fix the local geometry. On a trivalent three-colored tiling, each vertex $v$ lies on exactly three faces, and those three carry the three distinct colours — if two shared a colour they would be adjacent, contradicting the colouring. Why: this is the local content of the two lattice conditions, and it dictates that a vertex error touches three, not two or four, faces.

Step 2. Apply anticommutation. A $Z$ -face flags an error iff the error anticommutes with it: $X_v Z_f=(-1)^{[v\in f]}Z_f X_v$ . So $X_v$ anticommutes with exactly the three $Z$ -faces $Z_{f_r},Z_{f_g},Z_{f_b}$ containing $v$ , and commutes with all others. Why: the syndrome is nothing but the list of anticommuting stabilizers, and here it is a triple, not a pair.

Step 3. Read the colour charge. The three lit faces are one red, one green, one blue, so the total colour charge is $r\times g\times b=1$ : the excitation is colour-neutral, a global constraint every valid syndrome must satisfy. Why: charge neutrality is conserved by every subsequent error, so it is the algebraic backbone a correct decoder must respect.

Step 4. Draw the decoding consequence. Unlike surface-code defects, which come in matchable pairs, color-code defects come in colour-balanced clusters; pairing like colours cannot reproduce the true error. Decoders must respect the fusion rule directly (restriction and projection decoders) or first map to two surface codes and match there. Why: this is the origin of the color code's harder decoding problem — its central practical trade-off against the surface code. *The triple-defect structure is consistent with toric-code anyon fusion after the two-copy mapping of equation (6); the colour charge is conserved modulo the fusion algebra.*

Limiting cases

Color codes are best understood by the regimes they interpolate between and the familiar codes they contrast with.

Case	Result	Meaning
2D color code	$H,\,S,\,\mathrm{CNOT}$ transversal	Full Clifford group is transversal; by Eastin–Knill no transversal non-Clifford exists, so $T$ still needs magic states or code switching.
3D color code	$T$ or $CCZ$ transversal	A transversal non-Clifford appears, but transversal $H$ is lost; combining 2D and 3D blocks (dimension jump) restores universality.
Genus- $g$ closed surface	$k=4g$	Encodes $4g$ logical qubits, twice the toric code's $2g$ — the two-copy duality made quantitative.
Smallest instance	$[[7,1,3]]$ Steane code	A distance-3 triangle: 7 qubits, three weight-4 faces, transversal Clifford — the color code you can hold in your head.
Code-capacity threshold	$p_{\mathrm{th}}\approx 10.9\%$	Optimal (statistical-mechanics-mapped) threshold under independent bit/phase noise, matching the toric code; practical decoders achieve less.

Common trapColor-code decoding does NOT reduce to independent minimum-weight matching

The single most damaging misconception is to treat a color code like a surface code and decode by pairing up equal-coloured defects with minimum-weight perfect matching. It fails, because color-code excitations carry a conserved colour charge with the nontrivial fusion rule red × green = blue: a single Pauli error lights a triple of differently-coloured faces, not a matchable pair, so like-colour matching cannot even represent the true error. Correct decoders respect the three-colour fusion structure directly (the restriction and projection decoders, union-find, or neural-network variants) or first apply the local Clifford map to two surface codes and match there. A second, related trap concerns geometry: the boundaries of a planar color code must themselves be three-coloured, and choosing the boundary colours incorrectly destroys the encoded logical qubit rather than merely degrading it. Both mistakes share a root cause — importing surface-code intuition wholesale into a code whose defects are colour-charged.

Worked examples

1 · The 7,1,3 triangular color code, worked end to end

Take the smallest 2D color code: a triangle with a qubit at each of three corners, three edge-midpoints, and the centroid — seven qubits — carved into three weight-4 faces coloured red, green, blue. Count the code parameters, locate a logical operator, and verify the transversal Clifford claim.

Step 1. Count qubits and checks. There are $n=7$ vertices. Each of the three faces contributes one $X$ -check and one $Z$ -check, all weight 4, giving 6 generators. They commute: any $X$ -face and any $Z$ -face share either 0 or 2 qubits (two faces meet along a shared edge of two qubits), an even overlap. 6 independent generators on 7 qubits.

Step 2. Count logical qubits. The generators are independent, so $\operatorname{rank}(S)=6$ and $k=n-\operatorname{rank}(S)=7-6=\mathbf{1}$ . One logical qubit is encoded, and the code space has dimension $2^1=2$ . k = 1.

Step 3. Find the distance. A logical operator must commute with all six checks yet lie outside $S$ . The lightest such operators are weight-3 strings running along a coloured boundary of the triangle — for instance an $X$ on the three qubits of one edge. No weight-1 or weight-2 Pauli commutes with every check, so $d=3$ and $t=\lfloor(d-1)/2\rfloor=1$ : one arbitrary single-qubit error is correctable. d = 3, corrects t = 1.

Step 4. Verify the colour syndrome. An $X$ on the central qubit (which lies on all three faces) anticommutes with all three $Z$ -faces, lighting a red, green and blue defect: colour charge $r\times g\times b=1$ , colour-neutral as required. Central X error → three colour-balanced defects.

Step 5. Verify transversal Clifford. Since every face carries $X_f$ and $Z_f$ on the same qubits, bitwise Hadamard swaps them and acts as logical $H$ ; a checkerboard of $S/S^\dagger$ over the seven (bipartite) qubits acts as logical $S$ ; a bitwise CNOT to a second copy acts as logical CNOT. This $[[7,1,3]]$ code is exactly the Steane code, whose transversal Clifford group is textbook. Transversal H, S, CNOT = logical H, S, CNOT — the color code is the Steane code.

2 · Logical qubits on a hexagonal torus (Euler count with numbers)

Wrap the three-colored honeycomb onto a torus so that it has $F=9$ hexagonal faces. How many physical and logical qubits does it carry, and how does that compare with a toric code on the same surface?

Step 1. Get the qubit and edge counts. Nine hexagons with six edges each give $9\times 6=54$ edge-incidences; every edge is shared by two faces, so $E=54/2=27$ . Trivalency gives $E=\tfrac32 V$ , hence $V=\tfrac23 E=\mathbf{18}$ physical qubits. n = V = 18, E = 27.

Step 2. Check consistency with topology. On the torus $g=1$ , so the Euler characteristic must vanish: $V-E+F=18-27+9=0=2-2g$ . It does — the tiling is a legitimate closed surface. V − E + F = 0 ✓.

Step 3. Count independent generators. There are $2F=18$ raw face generators, minus the four colour-sum dependencies (two $X$ -type, two $Z$ -type), so $\operatorname{rank}(S)=2F-4=18-4=\mathbf{14}$ . 14 independent stabilizers.

Step 4. Read off the logical qubits. $k=n-\operatorname{rank}(S)=18-14=\mathbf{4}$ , matching the formula $k=4g=4\cdot 1=4$ . A toric code on the same torus encodes only $k=2g=2$ . k = 4, exactly twice the toric code's 2 — the two-copy duality in a single number.

Physics of the portrait

Color codes are the invention of a specific pair of theorists who asked what would happen if you put both an $X$ and a $Z$ check on every face — and found the whole 2D Clifford group waiting there.

Origins · 1 minHéctor Bombín and how this was discovered

Héctor Bombín

Spanish physicist, color codes 2006 · topological quantum codes and fault-tolerant computation

Héctor Bombín, working with his doctoral advisor Miguel Ángel Martín-Delgado at the Universidad Complutense de Madrid, introduced color codes in the 2006 paper "Topological Quantum Distillation" (Phys. Rev. Lett. 97, 180501). Their move was deceptively small: where Kitaev's toric code separated $X$ -stars from $Z$ -plaquettes, Bombín and Martín-Delgado placed both an $X$ -check and a $Z$ -check on every face of a three-colorable trivalent lattice. The consequence was large — the entire two-dimensional Clifford group became transversal, something the surface code cannot achieve, which they developed in "Topological Computation without Braiding" (2007). Bombín went on to build the surrounding theory almost single-handedly: 3D and higher-dimensional color codes with transversal non-Clifford gates, the "gauge color codes" that yield single-shot fault-tolerant error correction (Phys. Rev. X, 2015), the dimension-jump protocol for universality without magic-state distillation, and, with Guillaume Duclos-Cianci and David Poulin, the proof that the 2D color code is locally equivalent to two copies of the toric code. That last result reframed the whole family: color codes are surface codes wearing a coat that makes their Cliffords free. Now a researcher in industrial fault-tolerant architecture, Bombín remains the author whose name attaches to nearly every structural fact a student learns about these codes.

History

2006

— Bombín and Martín-Delgado introduce color codes in "Topological Quantum Distillation"

2007

— transversal Clifford gates on 2D color codes and 3D color codes are established

2012

— the 2D color code is shown to equal two decoupled copies of the toric code

2015

— Bombín's gauge color codes give single-shot fault-tolerant error correction

2024

— color-code logical qubits are demonstrated on trapped-ion and superconducting processors

Going further

Texts. Nielsen and Chuang, Quantum Computation and Quantum Information, ch. 10 (stabilizer and CSS codes) · Preskill, Lecture Notes for Physics 219, ch. 7 (quantum error correction, topological codes) · Kitaev, Shen and Vyalyi, Classical and Quantum Computation (stabilizer formalism, toric code) · Watrous, The Theory of Quantum Information (error-correction chapter) · Wilde, Quantum Information Theory, 2nd ed. (CSS and stabilizer codes) · Bombín and Martín-Delgado, "Topological Quantum Distillation," Phys. Rev. Lett. 97, 180501 (2006) · Bombín, "An Introduction to Topological Quantum Codes" (review, 2013). The key relations underlying this article are: the trivalent relation $3V=2E$ and Euler characteristic $V-E+F=2-2g$ , yielding $\operatorname{rank}(S)=2F-4$ and $k=4g$ (with the explicit torus check $g=1\Rightarrow k=4$ , $V=18$ , $E=27$ , $F=9$ , $k=4$ ); the CSS commutation $[X_f,Z_{f'}]=0$ from even overlaps via three-colorability; the single-qubit Clifford conjugations $HXH=Z$ , $HZH=X$ , $SXS^\dagger=Y$ , $S^\dagger XS=-Y$ , and the CNOT propagation rules; the three-colour syndrome and colour charge $r\times g\times b=1$ from trivalency; and the $[[7,1,3]]$ Steane identification, $k=7-6=1$ , $d=3$ . The optimal threshold $\approx 10.9\%$ and the color code = two surface codes duality are results of Bombín and Martín-Delgado (2006) and Bombín, Duclos-Cianci and Poulin (2012). The 2024 hardware demonstrations are the Google Quantum AI superconducting color-code result and Quantinuum trapped-ion Steane-code experiments.

Builds on: CSS Codes · Stabilizer Formalism · Code Distance and Logical Operators · Pauli Group and Clifford Group · Syndrome Measurement and Decoding. Leads to: Syndrome Measurement and Decoding · Quantum Hamming and Singleton Bounds.

Ask the tutor: name any lattice, boundary, or error pattern — a hexagonal torus, the seven-qubit triangle, or a two-qubit error — and I will compute the code parameters, the colour syndrome, and the transversal gates step by step.

Why does three-colorability matter so much — could I use any trivalent lattice?

No. Trivalency alone makes each vertex meet three faces, but it does not guarantee that $X$ -checks and $Z$ -checks commute. Three-colorability is what forces every pair of faces to overlap on an even number of qubits: same-coloured faces never touch (overlap zero), and different-coloured faces meet only along complete shared edges (overlap two, four, …). Even overlap gives $(-1)^{|f\cap f'|}=+1$ , so an $X$ -face and a $Z$ -face commute and the stabilizer group is abelian. Drop the colouring and some faces would overlap on an odd number of qubits, the checks would anticommute, and you would not have a valid CSS code at all. Three-colorability is the geometric encoding of the commutation condition.

In what sense is a color code "the same as" two surface codes?

There is a fixed, finite-depth circuit of local Clifford gates — a locally generated unitary $\mathcal U_{\mathrm{loc}}$ — that maps a 2D color code onto two independent copies of the toric (surface) code. "Same as" means same phase of matter: identical anyon content up to the mapping, identical code-capacity threshold, and a logical-qubit count that is exactly twice the toric code's, which is why $k=4g$ rather than $2g$ . What the mapping does not preserve is geometric locality of the gates in a simple way, so the color code keeps its distinctive transversal Clifford advantage even though its bulk physics is "two surface codes." The duality is a analytical gift: you can import surface-code results wholesale and still enjoy cheaper logic.

Why is color-code decoding harder than surface-code decoding?

In the surface code, a single error creates a pair of defects on a line, and decoding is minimum-weight perfect matching — pair up the defects along shortest paths. In the color code, a single error creates a triple of defects of three different colours (colour charge $r\times g\times b=1$ ), so there is no pair to match. The decoder must instead find a low-weight error consistent with a colour-neutral set of excitations, respecting the fusion rule red × green = blue. Practical strategies either work with the fusion structure directly (restriction decoder, union-find, neural nets) or apply the local Clifford map to two surface codes and match on each copy. All of this is more intricate than a single matching problem, which is the code's principal practical cost.

Why does the 2D color code get transversal H and S but the surface code does not?

Because in the color code every face carries $X_f$ and $Z_f$ on the same qubits, the stabilizer group is symmetric under exchanging $X\leftrightarrow Z$ . A bitwise Hadamard performs exactly that exchange, so it maps the stabilizer group to itself and acts as a logical Hadamard; a checkerboard of phase gates similarly preserves the group and acts as logical $S$ . The surface code separates $X$ -stars from $Z$ -plaquettes on differently-shaped, disjoint supports, so a bitwise Hadamard does not preserve its stabilizer group — logical $H$ there requires lattice surgery, code deformation, or twist defects. The whole difference in Clifford cost traces to one design choice: co-locating the two check types.

What is the smallest color code, and why is it worth knowing?

It is the distance-3 triangular color code: seven qubits, three weight-4 faces coloured red, green, blue, encoding one logical qubit with $k=7-6=1$ and $d=3$ . It is exactly the Steane code — the same $[[7,1,3]]$ CSS code students meet in every error-correction course — so the color-code construction reproduces a canonical code as its smallest member. It is worth knowing because everything general is visible in miniature: even overlaps make the checks commute, a central $X$ error lights all three colours, and bitwise $H$ , $S$ , CNOT act as logical Cliffords. If you can decode and operate the seven-qubit triangle by hand, you understand the family.

What do you gain and give up by choosing a color code over a surface code?

You gain transversal logical Cliffords — $H$ , $S$ , and CNOT as single layers of local gates rather than multi-cycle lattice-surgery operations — and you encode more logical qubits per unit of topology ( $4g$ versus $2g$ ). You give up two things. First, the stabilizers are heavier: weight-6 hexagons (or weight-4/8 on the 4.8.8 lattice) versus the surface code's weight-4 checks, which makes syndrome extraction circuits deeper and more error-prone. Second, decoding is harder and more sensitive to measurement noise, because colour-charged syndromes break the clean matching paradigm. The trade is therefore "cheaper logic, costlier checks and decoding" — attractive precisely when an algorithm's Clifford count dominates its cost.

Why go to three dimensions at all?

Because a single 2D stabilizer code can never have a transversal universal gate set — the Eastin–Knill theorem forbids a transversal non-Clifford gate for any code with a continuous logical symmetry, and the 2D color code's transversal set stops at the Clifford group. In three dimensions the color code gains a transversal non-Clifford gate ( $T$ or $CCZ$ ), but loses transversal $H$ . Bombín's dimension-jump protocol transfers a logical qubit between a 2D block (transversal Clifford) and a 3D block (transversal non-Clifford), so some block always implements the needed gate transversally — a route to universality that is an alternative to magic-state distillation. Three-dimensional color codes also exhibit single-shot error correction, cutting the number of measurement rounds a fault-tolerant cycle needs.