Color Codes

A two-dimensional color code places qubits on the vertices of a three-colorable, trivalent cellulation and assigns both an $X$ check and a $Z$ check to every face. The paired supports make the code CSS, while the three-colored geometry supplies boundary types, deformable logical strings, and an unusually rich set of ideal transversal Clifford operations. These features are related, but none substitutes for the others: local commuting checks do not determine the encoded dimension, a short boundary does not by itself prove distance, and a transversal Clifford group is not a universal fault-tolerant computer.

This page develops the two-dimensional qubit stabilizer family from its incidence conditions through finite experimental evidence. It first derives the closed-surface count, then freezes a seven-qubit triangular fixture whose checks, logical cosets, syndromes, distance, and gate phases can all be audited exactly. The later sections separate abstract decoding from extraction circuits and distinguish the two-dimensional gate statement from higher-dimensional and gauge-fixing constructions. The topological color-code construction was introduced by Bombín and Martín-Delgado in 2006; the algebraically identical seven-qubit Steane code predates that geometric interpretation.

Required background. Stabilizer Formalism supplies signed Pauli operators, stabilizer groups, normalizers, syndromes, and logical equivalence. CSS Codes supplies paired binary check matrices, rank counting, logical quotients, and axis distances.

Helpful background. Steane Code gives the algebraically identical seven-qubit Hamming presentation. Surface Code gives a neighboring two-dimensional topological CSS family with different qubit placement, boundaries, extraction circuits, and common decoder interfaces. All geometry, boundary, Pauli-phase, and stabilizer-sign conventions used here are nevertheless declared below.

A Three-Colorable Lattice and Its Face Checks

2-colex incidence conditions

Let $\Lambda=(V,E,F)$ be a connected, finite cellulation of a compact orientable surface. In the closed construction, every vertex has degree three and every face is labeled $r$, $g$, or $b$ so that faces sharing an edge have different labels. A regular cellulation is assumed: the boundary of each face is an embedded cycle, and two distinct faces meet only in incidence allowed by the cell structure. This trivalent, face-three-colorable object is often called a 2-colex.

Exactly three faces meet at an interior vertex, one of each color. Walking around a red face therefore alternates green and blue neighboring faces, so the face has even length. The same argument applies to the other colors. Two adjacent faces share the two endpoints of their common edge; disjoint faces have no shared vertex. These even-overlap properties, rather than the color names by themselves, are what the stabilizer proof uses.

Place one qubit at every $v\in V$. Face labels are combinatorial data, not physical Pauli axes and not necessarily literal optical colors in a device. For a patch with boundary, one must explicitly say which faces are truncated, which colored boundary segments are present, and whether corner incidences preserve all required even overlaps. Cutting an arbitrary region from a closed colex need not produce a valid code. A valid bounded patch is a new declared incidence structure whose checks must be verified again.

Paired face checks and commutation

For every face $f$, define positive stabilizer checks

$$S_f^X=\prod_{v\in f}X_v, \qquad S_f^Z=\prod_{v\in f}Z_v.$$

“Positive” fixes the code space to the $+1$ eigenspace of each generator. A different sign choice describes a different syndrome sector unless an explicit Pauli frame maps it back. Checks of the same Pauli type commute. For opposite types, the commutator is determined by support overlap:

$$S_f^X S_{f'}^Z =(-1)^{|f\cap f'|}S_{f'}^Z S_f^X.$$

When $f=f'$, the face has even size. When the faces differ, the declared 2-colex incidence gives either zero or two common vertices. Hence every $X$-face check commutes with every $Z$-face check. In binary language, if $H$ is the face–vertex incidence matrix, the two sectors use $H_X=H_Z=H$ and the same conclusion is

$$HH^{\mathsf T}=0\pmod 2.$$

This equation proves commutation, not independence. Products of face checks can equal the identity or one another, especially on a closed surface. The encoded dimension therefore depends on matrix ranks:

$$k=|V|-\operatorname{rank}H_X-\operatorname{rank}H_Z,$$

with each rank taken over $\mathbb F_2$. Raw face counts would overcount the number of stabilizer constraints.

Closed-surface counting

Assume now the standard connected, closed, orientable 2-colex of genus $g$, with no boundary and no additional dependencies beyond the color-product relations. Trivalence counts each edge endpoint once and gives

$$3|V|=2|E|.$$

Euler’s relation then yields

$$|V|-|E|+|F|=2-2g, \qquad |F|=\frac{|V|}{2}+2-2g.$$

For one Pauli sector, multiply all face checks of a given color. Each vertex occurs exactly once, so the red, green, and blue products all equal the all-vertex Pauli of that sector. Equality of these three products supplies two independent relations. Under the stated independence hypothesis, $\operatorname{rank}H=|F|-2$. Because the $X$ and $Z$ sectors have the same rank,

$$\begin{aligned} k &=|V|-2(|F|-2)\\ &=|V|-2\left(\frac{|V|}{2}+2-2g\right)+4\\ &=4g. \end{aligned}$$

Thus the sphere encodes no qubit in this closed construction, while a torus encodes four. The result is a theorem about the declared closed family, not a universal formula for anything called a color code. Boundaries alter Euler counting, remove or change checks, and change dependency relations. Triangular planar patches are designed precisely so that a genus-zero region can encode one logical qubit.

What topology does and does not guarantee

Topology organizes equivalence classes of extended Pauli operators. It does not, without further hypotheses, specify their minimum weight, the physical noise, or the performance of a decoder. The following table keeps the stable claims beside their ownership boundaries.

Datum	Exact condition	Consequence
2-colex	Connected trivalent cellulation with properly three-colored faces and declared boundary incidences	Vertex qubits and even face intersections define the geometric family; a drawing without these conditions is insufficient.
Paired face checks	$S_f^X$ and $S_f^Z$ use the same support and satisfy $H_XH_Z^{\mathsf T}=0$	CSS Codes is the mathematical superclass and retains general binary matrices and logical quotients.
Independent rank	$k=	V
Closed surface	Connected, closed, orientable standard construction with exactly two color-product relations per sector	Euler counting gives $k=4g$; the formula does not survive unchanged after introducing a boundary.
Bounded patch	Truncated checks, colored sides, corners, signs, and ranks are explicitly declared	The seven-qubit triangular patch is the same $[[7,1,3]]$ stabilizer as the Steane code under relabeling, while Steane Code retains the Hamming derivation.
Logical representatives	Normalizer strings or string nets are identified modulo products of face checks	Geometrically different supports can be one logical class; colored endpoints constrain which deformations are legal.
Distance and neighboring families	$d$ is the minimum weight of a nontrivial logical coset for the declared patch	Surface Code is a distinct 2D topological CSS family; bounded patches and decoders are not unrestrictedly equivalent, while Topological Codes owns the shared taxonomy, homological dictionary, and active-versus-passive distinction.
Locality	Growing regular 2D families have bounded face weight and bounded qubit degree	They meet a qLDPC sparsity definition, while Quantum LDPC Codes retains Tanner graphs, asymptotic constructions, schedules, and architecture evidence.
Rate and extensions	Locality alone neither proves finite asymptotic rate nor fixes a gauge presentation	Subsystem Codes owns gauge centers, dressed logicals, gauge-derived syndromes, and general gauge fixing; gauge color codes are related extensions, not the same fixed stabilizer description.
Gates and operations	Gate claims state dimension, divisibility, locality, and code-preservation hypotheses	Higher-dimensional color codes require separate conditions; Lattice Surgery retains merges, splits, seams, schedules, and surgery evidence.

The Seven-Qubit Triangular Color Code

Frozen faces, checks, and logical representatives

Number qubits from one through seven and read binary and Pauli strings from qubit one on the left. Freeze the three face supports

$$r=\{1,2,3,4\},\qquad g=\{2,3,5,6\},\qquad b=\{3,4,6,7\}.$$

Each pair of distinct faces overlaps on two vertices, and every face has weight four. The six positive generators, in ordered $X$ then $Z$ sectors, are

$$\begin{aligned} S_r^X&=\mathord{\mathrm{XXXXIII}},& S_g^X&=\mathord{\mathrm{IXXIXXI}},& S_b^X&=\mathord{\mathrm{IIXXIXX}},\\ S_r^Z&=\mathord{\mathrm{ZZZZIII}},& S_g^Z&=\mathord{\mathrm{IZZIZZI}},& S_b^Z&=\mathord{\mathrm{IIZZIZZ}}. \end{aligned}$$

No minus signs or hidden coordinate permutation are present. Let $\ell=1111111$ and choose

$$\overline X=X(\ell), \qquad \overline Z=Z(\ell).$$

The common support has odd cardinality, so the representatives anticommute. Multiplying either by a same-type face check changes its support without changing its logical class. In particular, the three boundary-side supports $\{1,2,5\}$, $\{5,6,7\}$, and $\{1,4,7\}$ are minimum-weight representatives of the same corresponding logical Pauli class.

Seven-qubit triangular color-code fixture in the frozen vertex convention. The labeled quadrilateral faces have supports $r=\{1,2,3,4\}$, $g=\{2,3,5,6\}$, and $b=\{3,4,6,7\}$; each supplies paired checks $X_f$ and $Z_f$. Filled and open qubit markers encode $A=\{1,3,5,7\}$ and $B=\{2,4,6\}$ for the alternating $S/S^\dagger$ phase-gate convention, while the bold side $\{1,2,5\}$ is one minimum-weight logical support. The drawing fixes this finite incidence structure only: it is not a general-distance geometry, decoder graph, hardware layout, or syndrome-extraction schedule.

The three-row incidence matrix

The face–vertex incidence matrix is

$$H_X=H_Z=H= \begin{pmatrix} 1&1&1&1&0&0&0\\ 0&1&1&0&1&1&0\\ 0&0&1&1&0&1&1 \end{pmatrix}.$$

Its rows are independent: the first is the only row with a one in column one, the second is then the only remaining row with a one in column two, and the third is nonzero. Hence $\operatorname{rank}H=3$. Every row has even weight and every distinct pair overlaps twice, giving $HH^{\mathsf T}=0$. The six stabilizer generators are therefore independent and commuting, so

$$k=7-3-3=1.$$

The exact fixture is summarized without importing the Hamming derivation from the Steane page.

Fixture item	Frozen value	Audit consequence
Faces	$r=\{1,2,3,4\}$, $g=\{2,3,5,6\}$, $b=\{3,4,6,7\}$	All face weights and pairwise overlaps are even.
Matrix	$H_X=H_Z=H$ with rows $1111000$, $0110110$, $0011011$	Binary matrix products reproduce all six printed checks.
Rank	$\operatorname{rank}H=3$ and $HH^{\mathsf T}=0$	Six independent commuting checks encode $k=7-3-3=1$.
Stabilizer	Positive group generated by three $X$ faces and three $Z$ faces	The phase-free support group has $2^6=64$ elements.
Row space	Zero plus seven weight-four words	No nonidentity pure-sector stabilizer has weight below four.
Kernel and logical coset	$\ker H=\operatorname{row}(H)\sqcup[\ell+\operatorname{row}(H)]$	The second coset has one weight-seven and seven weight-three words.
Normalizer	$x,z\in\ker H$ for $E(x,z)=X(x)Z(z)$	There are $16^2=256$ phase-free normalizer representatives and four stabilizer cosets.
Syndromes	Columns $(100,110,111,101,010,011,001)$ in the declared order	The 21 weight-one Paulis have distinct nonzero six-bit syndromes.
Phase partition	$A=\{1,3,5,7\}$ and $B=\{2,4,6\}$	Every face contains two vertices of each part, fixing the alternating $S/S^\dagger$ audit.
Distance	$d_X=d_Z=d=3$	Weight-three logicals exist and exhaustive quotient enumeration excludes lighter ones.

Stabilizer and normalizer enumeration

The row space of $H$ contains zero and the seven weight-four words

$$\begin{gathered} 1111000,\quad 0110110,\quad 0011011,\quad 1001110,\\ 1100011,\quad 0101101,\quad 1010101. \end{gathered}$$

Because $HH^{\mathsf T}=0$, this three-dimensional row space lies inside the four-dimensional kernel. The other kernel coset is $\ell+\operatorname{row}(H)$. It contains $1111111$ and seven words of weight three:

$$0000111,\quad1001001,\quad1100100,\quad0110001, \quad0011100,\quad1010010,\quad0101010.$$

For the phase-free convention $E(x,z)=X(x)Z(z)$, commutation with every face check requires $x,z\in\ker H$. There are consequently $16^2=256$ normalizer representatives. The stabilizer has $8^2=64$ support representatives, and the normalizer quotient has four elements: identity, logical $X$, logical $Z$, and logical $XZ$. Each logical class contains 64 representatives.

An exhaustive traversal of all $4^7=16384$ phase-free Paulis gives 64 syndrome sectors with 256 Paulis in every sector. It also gives the normalizer weight distribution

$$\{0{:}1,\ 3{:}21,\ 4{:}21,\ 5{:}126,\ 6{:}42,\ 7{:}45\}.$$

The identity stabilizer coset has distribution $\{0{:}1,4{:}21,6{:}42\}$, while each of the three nontrivial logical cosets has $\{3{:}7,5{:}42,7{:}15\}$. These finite counts cross-check the rank, quotient size, and exact distance independently of the picture.

Equivalence without duplication

This triangular block and the Steane code are the same $[[7,1,3]]$ stabilizer code after an explicit qubit relabeling and row-basis choice. “Same code” here means that a coordinate permutation and stabilizer-generator changes identify their code spaces and logical Pauli classes. It does not mean their printed syndrome columns or preferred representatives may be mixed without tracking that map.

The two pages answer different questions. The Steane page owns the classical Hamming inclusion, normalized coset basis, its fixed syndrome ledger, recovery convention, and code-specific gate fixture. This page owns the triangular geometry as the smallest member of a scalable 2-colex family, including colored boundaries, string deformation, dimension-sensitive gate claims, and color-code decoder interfaces. Bombín and Martín-Delgado’s 2006 construction provides that geometric interpretation; it did not discover the earlier Steane code retroactively.

Nor does an unfolding, projection, or local-equivalence theorem erase family data. Such a statement has hypotheses about closed versus bounded geometry, ancillas, locality, and allowed transformations. It can relate algebraic sectors while leaving boundary types, extraction circuits, decoding maps, and hardware costs different. Claims of equivalence should therefore name the objects and transformations, not replace them with an unrestricted slogan.

Syndrome Algebra and Exact Distance

Ordered syndrome convention

Retain physical phases when conjugating operators, but use the phase-free support label

$$E(x,z)=X(x)Z(z), \qquad Y_j=iX_jZ_j$$

for syndrome and quotient calculations. Order syndrome bits by the printed faces $r,g,b$, with the $Z$-check outcomes first and the $X$-check outcomes second:

$$\sigma(E)=(s_Z\mid s_X) =(Hx^{\mathsf T}\mid Hz^{\mathsf T}).$$

The matrix columns are

$$(h_1,\ldots,h_7) =(100,110,111,101,010,011,001).$$

An $X_j$ error anticommutes with the $Z$ checks containing vertex $j$, hence has syndrome $h_j\mid000$. A $Z_j$ error has $000\mid h_j$, and a $Y_j$ error has $h_j\mid h_j$. The labels “$s_Z$” and “$s_X$” name the measured check sectors, not the Pauli component being inferred; stating this convention prevents a common swap.

Complete weight-one audit

The twenty-one entries are compactly

$$\begin{aligned} X_1,\ldots,X_7: &\quad100|000,\ 110|000,\ 111|000,\ 101|000,\\ &\quad010|000,\ 011|000,\ 001|000;\\ Z_1,\ldots,Z_7: &\quad000|100,\ 000|110,\ 000|111,\ 000|101,\\ &\quad000|010,\ 000|011,\ 000|001;\\ Y_1,\ldots,Y_7: &\quad100|100,\ 110|110,\ 111|111,\ 101|101,\\ &\quad010|010,\ 011|011,\ 001|001. \end{aligned}$$

All are nonzero because every column of $H$ is nonzero. They are distinct within a Pauli type because the columns are distinct, and distinct across types because the pattern of zero and nonzero halves differs. The no-error sector is $000|000$, so an ideal, perfect syndrome identifies every weight-one Pauli support and type for this fixture.

That statement is not a circuit-level recovery claim. A faulty extraction circuit can corrupt data, flip several syndrome bits, correlate rounds, or leak outside the qubit subspace. Even under ideal measurement, higher-weight errors can share a syndrome with a lower-weight representative while differing by a logical operator. Syndrome is an equivalence-class label for stabilizer commutation, not a unique microscopic error history.

Degeneracy, logical collisions, and distance

No weight-one or weight-two nonzero binary word lies in $\ker H$. For weight one this follows from nonzero columns; for weight two it follows because two distinct columns cannot sum to zero. If a phase-free Pauli of total weight at most two normalized the stabilizer, both its $x$ and $z$ components would be kernel words of weight at most two and hence zero. Therefore no nonidentity normalizer has weight below three.

The kernel coset already exhibits weight-three representatives. For example, $\ell+b=1100100$ supports $\{1,2,5\}$, while $\ell+r=0000111$ supports $\{5,6,7\}$ and $\ell+g=1001001$ supports $\{1,4,7\}$. Applying the same support as $X$ or $Z$ produces a nontrivial normalizer. Hence

$$d_X=d_Z=d=3.$$

This argument identifies both a lower bound and a witness attaining it. Calling the side length “three” would not be a substitute: the equality of side length and code distance is a property proved for a declared patch family. The quotient enumeration also displays degeneracy at higher weight. Errors differing by a stabilizer act identically on the code, whereas errors with the same syndrome but different logical cosets cause a decoder collision. The distinction is central when comparing decoders.

Colored Boundaries and Logical Strings

Three boundary colors

A bounded triangular color-code patch has three side types conventionally labeled red, green, and blue. A boundary color records which colored string operator may terminate or condense there under the chosen lattice convention. Corners join two boundary types and therefore need their own incidence check. The labels do not mean that an arbitrary string of same-colored edges is automatically logical; it must commute with all retained stabilizers and have the allowed endpoints.

In the seven-qubit fixture, the supports $\{1,2,5\}$, $\{5,6,7\}$, and $\{1,4,7\}$ trace the three sides in the selected embedding. Each is obtained from the all-seven representative by multiplying one face support. Thus the three geometrically different sides lie in one logical-$X$ coset when decorated with $X$, and in one logical-$Z$ coset when decorated with $Z$. The face color used in the multiplication identifies the deformation between representatives.

For a larger patch, strings may branch into string nets. At a branching point, color and Pauli labels must satisfy the local commutation constraints. Closed contractible pieces are products of face checks and are logically trivial; noncontractible or boundary-to-boundary structures can be logical. This is the geometric realization of the normalizer quotient, not an alternative to it.

Deforming equivalent representatives

Multiplying a Pauli string by $S_f^X$ or $S_f^Z$ toggles its support around a face without changing its action on the code space. A sequence of such moves deforms a representative through the lattice. The invariant is its stabilizer coset together with its allowed boundary endpoints, not its drawn path.

This freedom is useful and dangerous. It lets a compiler route a logical representative away from a defective region or select a convenient support for a parity measurement. But a deformation through a corner, puncture, twist, or temporarily changed check set can change the logical class. One must verify commutation with the stabilizer group before and after the move and track any measured eigenvalue or Pauli-frame update.

Local equivalence to copies or sectors of surface-code-like models can make these homological classes easier to analyze. It does not identify every bounded color-code string with one surface-code string. Boundary conditions, ancillary degrees of freedom, and the lifting map matter. The same caution applies to decoder projections: a projected solution must be lifted back to a valid color-code recovery with the intended logical class.

Locality, rate, and scaling

In a regular growing 2-colex family, face size is bounded and each vertex participates in a bounded number of checks. The family is therefore qLDPC in the sparsity sense. This does not imply a nonzero asymptotic encoding rate. For familiar planar triangular families, the number of data qubits grows like an area while the number of encoded qubits stays fixed and the distance grows like a linear dimension, so the rate vanishes.

Likewise, geometric locality does not establish a threshold. A threshold statement needs a sequence of codes, a noise model, extraction schedule, decoder, logical failure definition, and scaling study. Boundaries and corners can control the shortest logical path; circuit ordering can create hook errors that reduce effective distance; leakage or correlated noise can invalidate an independent-Pauli model. Those data belong in the architecture contract.

Color codes can trade higher-weight checks and decoder complexity against their gate structure. Whether that trade is favorable depends on hardware connectivity, native entangling operations, measurement and reset, ancilla resources, classical latency, and the logical workload. Code parameters alone do not rank architectures.

Transversal Clifford Gates

Bitwise Hadamard and blockwise CNOT

On every qubit, Hadamard exchanges $X$ and $Z$. Because the frozen color code has identical face supports in the two sectors,

$$H^{\otimes7}S_f^XH^{\otimes7}=S_f^Z, \qquad H^{\otimes7}S_f^ZH^{\otimes7}=S_f^X.$$

The stabilizer group is preserved. The all-seven logical representatives are also exchanged, so the induced operation is logical Hadamard. This conclusion uses both equal check supports and the declared representatives; a generic CSS code need not admit bitwise Hadamard.

For two identically ordered blocks, apply physical CNOT from qubit $j$ of the control to qubit $j$ of the target for every $j$. The Pauli conjugation rules map each control $X$ face to the product of matching control and target faces, and each target $Z$ face to the corresponding product. Target $X$ faces and control $Z$ faces remain in their blocks. The same calculation on $\overline X$ and $\overline Z$ gives the logical-CNOT conjugations.

These are ideal code-preservation arguments. Transversality limits propagation within a block because one elementary gate never couples two qubits of that block, but a complete fault-tolerance claim must include faulty locations, incoming errors, extraction, and recovery. Fault-Tolerant Gates owns that gadget-level contract.

The bipartite phase convention

Freeze the bipartition

$$A=\{1,3,5,7\},\qquad B=\{2,4,6\}$$

and the physical operation

$$U_P=\bigotimes_{j\in A}S_j \bigotimes_{j\in B}S_j^\dagger.$$

Single-qubit conjugation gives

$$SXS^\dagger=iXZ, \qquad S^\dagger XS=-iXZ,$$

while both operations fix $Z$. Every frozen face contains exactly two vertices in $A$ and two in $B$. Its phase is therefore $i^2(-i)^2=+1$, and

$$U_PS_f^XU_P^\dagger=+S_f^XS_f^Z, \qquad U_PS_f^ZU_P^\dagger=S_f^Z.$$

The all-seven logical support has four vertices in $A$ and three in $B$, so its phase is $i^4(-i)^3=i$. Consequently,

$$U_P\overline XU_P^\dagger =i\overline X\overline Z=\overline Y, \qquad U_P\overline ZU_P^\dagger=\overline Z.$$

The declared operation implements logical $S$. The factor $i$ is essential: although $E(x,z)=X(x)Z(z)$ is a useful phase-free label, Hermitian $Y=iXZ$ fixes the signed logical conjugation. Uniform $S^{\otimes7}$ instead has phase $i^7=-i$ on the all-seven $X$ representative and implements the opposite logical phase direction in this convention.

Clifford completion and the universality boundary

Logical Paulis, the operations just audited, and blockwise CNOT generate the logical Clifford group. They do not form a universal quantum gate set. Under the Bravyi–König hypotheses, locality-preserving constant-depth gates in growing two-dimensional local stabilizer codes lie at the Clifford level. This dimensional restriction is the relevant one for the family developed here, and it supports rather than evades the conclusion.

Eastin–Knill supplies a different no-go statement: under its assumptions, one fixed exact finite-dimensional quantum code cannot possess a universal set of transversal logical gates. It does not forbid useful individual transversal gates. Higher-dimensional color codes can realize gates at higher levels of the Clifford hierarchy, but only with additional geometric and divisibility conditions. Those results are not extra transversal gates of the same fixed 2D patch.

The hypotheses must travel with any comparison. Constant depth is a statement about how circuit depth scales with code size, locality refers to a specified interaction geometry, and transversality forbids coupling multiple coordinates inside one block. These properties overlap in familiar constructions but are not interchangeable definitions. A gate can preserve the stabilizer algebra without having a local physical implementation, and a coordinatewise gate can still participate in a faulty protocol whose preparation or recovery spreads errors. Conversely, a nontransversal logical operation may be fault tolerant when its complete gadget contains faults and preserves correctability. Naming the code dimension, growing family, physical gate pattern, and fault model is therefore part of the mathematical claim, not optional architectural detail.

Gauge fixing changes which stabilizer or gauge operators are measured so that information moves between code descriptions. Bombín’s gauge-color-code construction shows how this mechanism can organize useful gate sets, but it does not prove that one unchanged 2D stabilizer color code has a universal transversal set. Universal completion can instead use state injection, teleportation, switching, or another protected non-Clifford resource, each with its own verification and overhead.

Decoding and Fault-Tolerant Operations

Check extraction is a separate object

The stabilizer support says which Pauli observable is desired; it does not say how a device measures it. A circuit must choose ancillas, entangling-gate order, verification or flagging, reset, measurement basis, and repetition in time. A single ancilla fault can propagate through a weight-four check unless the ordering and ancillary structure contain it. Different faces can also compete for the same qubit or coupling resource.

Three decoding contracts must therefore remain distinct. Code capacity assumes perfect syndrome data and data errors only. A phenomenological model repeats abstract syndrome bits and permits measurement errors, usually without representing the gate circuit that produced them. A circuit-level model places faults in a declared extraction circuit and includes propagation, correlations, time ordering, and any leakage assumptions. A decoder result in one model cannot be relabeled as a result in another.

Syndrome Measurement owns the general measurement-instrument and detector construction. The color code contributes its face incidences and boundary geometry. A complete study must join the two: the decoder consumes detector records from the implemented circuit, not timeless ideal face eigenvalues.

Projection, restriction, and direct decoding

Color-code decoding asks for a recovery coset compatible with the observed record and chosen noise model. Projection or restriction methods map parts of the color-code problem to surface-code-like decoding problems. Delfosse’s projection construction and the later framework of Kubica and Delfosse make that relationship precise under declared lattice and dimension hypotheses. The projected answers must still be lifted and combined into a valid color-code recovery.

It is therefore misleading to summarize the method as “run matching three times.” The projections may carry correlated information, boundaries may couple sectors, and independently optimal projected answers need not lift to a globally optimal color-code class. A direct decoder can instead operate on the original checks. Lee, Li, and Bartlett analyze a color-code decoder designed for circuit-level noise, illustrating why the extraction circuit and scaling criterion belong in the claim rather than in a decoder label alone.

The finite fixture makes the lifting obligation concrete. A proposed recovery must reproduce the measured six-bit syndrome, but that condition leaves four logical classes among the 256 representatives in the sector. Adding a stabilizer changes no encoded action; adding a logical normalizer preserves the syndrome while changing the decoded qubit. A projection can identify locally plausible chains without deciding this global quotient correctly. Correlated $Y$ noise also enters both syndrome halves at once, so discarding their joint likelihood can lose information even though the stabilizer checks are CSS. With noisy measurements, the object to lift is a spacetime history rather than one spatial chain. Boundaries determine which endpoints are admissible, and the extraction circuit determines which detector combinations a single fault can create. These facts explain why decoder names alone are poor performance descriptions: the mathematical map, probabilistic model, and final logical classification must all be specified.

Direct, projection, restriction, lookup, and correlated decoders can be compared only when noise, boundary, extraction, number of rounds, postselection, and logical-failure definitions agree. Decoders retains the general inference objective, priors, calibration, confidence, throughput, and latency. This page retains the color-code-specific mapping and lifting interface.

Surgery, gauge fixing, and code switching

Logical operations can be built by changing which joint observables are measured, deforming boundaries, switching code descriptions, or consuming verified resource states. A triangular colex patch and its three boundary types provide inputs to those methods, but they do not determine a protocol. A surgery claim must state the patches, seams, temporary checks, rounds, decoder handoff, outcome signs, and Pauli-frame updates.

Gauge fixing similarly requires an initial gauge or stabilizer group, a final one, the newly measured operators, and a correction rule. Code switching requires maps between logical subspaces and must protect intermediate steps. Neither phrase licenses silently adding a higher-dimensional gate to the fixed seven-qubit stabilizer. Bombín’s 2015 gauge-code result is evidence for a specific construction under its assumptions, not a generic shortcut.

Lattice Surgery owns merges, splits, parity projectors, seams, spacetime decoding, schedules, and routing. Fault-Tolerant Gates owns error-spread and gadget correctness, the Eastin–Knill interpretation, non-Clifford completion, and switching criteria. Keeping these boundaries explicit prevents an ideal logical algebra from being mistaken for a deployable fault-tolerant instruction.

Experimental Evidence Through 25 August 2026

What finite demonstrations establish

Evidence is cut off at 25 August 2026. The table reports the encoded object and operation actually demonstrated, with postselection and dimensionality kept visible.

Source and year	Demonstrated scope	Boundary on the claim
Nigg et al. (2014)	Operations on one seven-qubit trapped-ion encoded qubit	Not repeated fault-tolerant correction and not a scaling result.
Ryan-Anderson et al. (2021)	One $[[7,1,3]]$ block with seven data qubits and three ancillas; fault-tolerant initialization, single-qubit Clifford control, repeated syndrome extraction, real-time decoding, and correction	No two-logical-qubit entangling gate was demonstrated in that experiment.
Postler et al. (2022)	Two trapped-ion logical qubits, a fault-tolerant logical CNOT, fault-tolerant magic-state preparation, and an injected logical $T$	Not distance scaling or a sustained large computation.
Bluvstein et al. (2024)	Forty distance-three 2D color-code blocks on 280 atoms; all were initially encoded non-fault-tolerantly, then twenty transversal CNOTs used half as logical flags to fault-tolerantly initialize the other twenty; bounded four-logical-qubit GHZ and feedforward teleportation results	The paper’s 48 logical qubits were instead sixteen 3D $[[8,3,2]]$ blocks on 128 atoms, with 228 logical CZ/CNOT and 48 logical CCZ gates, non-fault-tolerant preparation, and postselected detection; they are not a 48-block 2D result.
Lacroix et al. (2025)	Superconducting distance-three-to-five memory scaling with suppression factor $1.56(4)$, logical Clifford benchmarking, postselected magic-state injection above 99%, and bounded lattice-surgery teleportation	Memory scaling does not establish surgery scaling or sustained algorithm depth.
Bluvstein et al. (2026)	Bounded neutral-atom universal-architecture primitives, including ancilla-mediated logical product measurement	Not a sustained large routed workload with repeated correction at scale.

Nigg and colleagues established coherent control of one encoded block, a different evidential category from repeated active correction. Ryan-Anderson and colleagues added repeated extraction, real-time decoding, and correction for one block. Postler and colleagues demonstrated a two-logical-qubit fault-tolerant CNOT and non-Clifford injection. These milestones progressively test more of a protocol, but none alone establishes distance scaling or an asymptotic threshold.

The 2024 neutral-atom result must be parsed especially carefully. Forty distance-three two-dimensional blocks and forty-eight logical qubits in three-dimensional $[[8,3,2]]$ blocks are separate experiments within the same paper. The latter used non-fault-tolerant preparation and postselected error detection. Mixing the numbers erases the code dimension and changes the claim. Lacroix and colleagues later reported distance-three-to-five memory scaling on superconducting hardware, while the bounded surgery and injection demonstrations retained their own acceptance and protocol conditions. The 2026 neutral-atom work extends architecture primitives without yet becoming a sustained routed computation at scale.

What remains architecture-dependent

Postselection discards outcomes according to an acceptance rule; its conditional logical fidelity must be reported with acceptance probability and resource cost. Error detection identifies some faults without necessarily returning an accepted state after every trial. Active repeated correction updates or applies a recovery while retaining the run. These are not synonyms.

A break-even comparison needs a matched physical baseline and a declared task. Distance scaling compares multiple code sizes under controlled conditions; one good finite block cannot establish it. Logical-gate benchmarking measures an operation channel or sequences under a stated protocol. End-to-end algorithmic evidence additionally includes preparation, routing, correction, feedforward, non-Clifford resources, measurement, and total failure accounting. A result at one layer should not be promoted to another.

No finite experiment by itself proves an asymptotic threshold or universal resource advantage. Connectivity, shuttling or atom movement, native gates, ancilla supply, check scheduling, leakage treatment, decoder latency, and classical control are architecture-specific. The evidence supports concrete finite achievements under declared conditions; extrapolation requires a model whose assumptions remain visible.

An informative report consequently separates the data-qubit count from every ancilla and flags whether preparation was fault tolerant, detected, or merely encoded. It states how many correction rounds were retained, which shots were discarded, how a logical failure was scored, and whether feedforward completed before the next protected operation. When several code distances are present, the fitted suppression factor must be tied to the same memory task and noise regime; it cannot be transferred automatically to a surgery sequence or gate benchmark. When several code dimensions occur in one device study, each block family needs its own parameters and preparation conditions. These reporting rules do not diminish a finite demonstration. They identify exactly which part of a fault-tolerant stack has survived experimental contact and which parts remain projections, simulations, or engineering requirements.

Exercises

1. Verify the face checks

Using the three frozen face supports, verify all $X$–$Z$ commutators, compute $\operatorname{rank}H$, and determine the number of encoded qubits. Explain why counting six printed generators is safe here but raw face counting is unsafe in the closed construction.

Solution

Every face has weight four, so its own $X$ and $Z$ checks overlap evenly. Distinct faces intersect as $r\cap g=\{2,3\}$, $r\cap b=\{3,4\}$, and $g\cap b=\{3,6\}$, again evenly. Thus $HH^{\mathsf T}=0$. The rows are independent because column one isolates the first row, after removing it column two isolates the second, and the third is nonzero. Therefore each sector has rank three and $k=7-3-3=1$. Here the six checks are independent. On a closed colex, color-product relations make two dependencies per sector, so face count alone would overcount constraints.

2. Enumerate the logical coset

Enumerate $\operatorname{row}(H)$ and $\ell+\operatorname{row}(H)$ for $\ell=1111111$. Identify the weights and show how the three declared side supports arise.

Solution

The row space consists of $0000000$ and $1111000,0110110,0011011,1001110,1100011,0101101,1010101$; all seven nonzero words have weight four. Adding $\ell$ gives $1111111$ and $0000111,1001001,1100100,0110001,0011100,1010010,0101010$. Thus the logical coset contains one weight-seven and seven weight-three words. Specifically, $\ell+r=0000111$ supports $\{5,6,7\}$, $\ell+g=1001001$ supports $\{1,4,7\}$, and $\ell+b=1100100$ supports $\{1,2,5\}$. Multiplication by the corresponding face stabilizer implements each deformation.

3. Reproduce the syndrome ledger

With $\sigma(E)=(Hx^{\mathsf T}\mid Hz^{\mathsf T})$, derive the syndromes of all $X_j$, $Z_j$, and $Y_j$. Prove that the 21 results are nonzero and distinct without relying on a lookup table.

Solution

For $X_j$, $x=e_j,z=0$, so $\sigma(X_j)=h_j|000$. For $Z_j$, $\sigma(Z_j)=000|h_j$, and for $Y_j=iX_jZ_j$ both binary components are $e_j$, giving $h_j|h_j$. The columns $100,110,111,101,010,011,001$ are precisely the seven distinct nonzero three-bit words. Hence no entry is zero, entries within each Pauli type are distinct, and entries in different types have different patterns of zero halves. This proves the complete 21-entry claim.

4. Prove the exact distance

Prove $d_X=d_Z=d=3$ directly from the columns of $H$ and one logical witness. Then explain what the normalizer enumeration adds to the proof.

Solution

A nonzero weight-one kernel word would require a zero column, and a weight-two kernel word would require two equal columns. Neither occurs. If a Pauli of total weight at most two normalized the code, both binary components would be kernel words of weight at most two and hence zero. The word $1100100$ lies in $\ell+\operatorname{row}(H)$ and supports a nontrivial weight-three $X$ or $Z$ logical, proving the matching upper bound. Thus both axis distances and the full Pauli distance equal three. Enumeration independently confirms that the normalizer has no weights one or two and has 21 weight-three elements, while assigning every representative to one of four size-64 logical cosets.

5. Derive the closed-surface dimension

For a connected closed orientable trivalent 2-colex of genus $g$, assume that the only face-check dependencies in each sector are the two independent color-product relations. Derive $k=4g$ and identify why the proof fails for a triangular patch.

Solution

Trivalence gives $3|V|=2|E|$. Combining this with $|V|-|E|+|F|=2-2g$ gives $|F|=|V|/2+2-2g$. The three products over red, green, and blue faces each produce the all-vertex Pauli, so their equality gives two independent relations and $\operatorname{rank}H=|F|-2$ in each sector. Therefore $k=|V|-2(|F|-2)=|V|-2(|V|/2+2-2g)+4=4g$. A triangular patch has boundary, truncated incidences, different check dependencies, and different Euler data; substituting $g=0$ into the closed formula would incorrectly give zero instead of its directly ranked value one.

6. Track the bipartite phase gate

For $A=\{1,3,5,7\}$ and $B=\{2,4,6\}$, track every $X$-face check, every $Z$-face check, and both all-seven logical representatives under $U_P$. Why may the phase-free binary label not discard the resulting factor $i$?

Solution

Each face contains two $A$ and two $B$ vertices. Conjugating its $X$ check therefore contributes $i^2(-i)^2=+1$ and one $Z$ on the same support, giving $S_f^X\mapsto+S_f^XS_f^Z$ for $f=r,g,b$. Every $Z$ check is fixed. The all-seven support contains four $A$ and three $B$ vertices, so its phase is $i^4(-i)^3=i$. Hence $\overline X\mapsto i\overline X\overline Z=\overline Y$ and $\overline Z\mapsto\overline Z$, which is logical $S$. The binary label $E=XZ$ suppresses global phases for commutation and cosets, but $Y=iXZ$ is a Hermitian operator; dropping $i$ would reverse the signed logical conjugation.

7. Separate decoding and gate claims

Classify the following claims and state the missing evidence: (a) a decoder corrects ideal data errors with perfect syndrome; (b) a simulation flips abstract syndrome bits over repeated rounds; (c) a hardware circuit includes ancilla faults and hook propagation; (d) bitwise Clifford preservation proves a universal fault-tolerant gate set.

Solution

(a) is code capacity and does not establish measurement-noise or circuit-level performance. (b) is phenomenological and still lacks a physical extraction circuit. (c) is circuit level only if its gate ordering, correlations, time, leakage assumptions, and failure rule are declared. Comparisons among the three also require the same boundaries, postselection, and logical metric. (d) is false: the audited operations are Clifford and therefore not universal. A universal claim needs a protected non-Clifford resource and a full gadget analysis; Bravyi–König constrains locality-preserving gates in 2D, while Eastin–Knill rules out a universal transversal set under its distinct assumptions.

8. Audit an evidence claim

Audit the statement: “Bluvstein et al. demonstrated 48 distance-three two-dimensional color-code blocks with fault-tolerant preparation in 2024, so the experiment established scalable universal fault tolerance.” Replace it with a bounded statement.

Solution

The statement conflates two parts of one paper. The 2D result used forty distance-three color-code blocks on 280 atoms. All forty were initially encoded non-fault-tolerantly; twenty transversal CNOTs then used half as flags to fault-tolerantly initialize the other twenty. The 48 logical qubits were instead sixteen 3D $[[8,3,2]]$ blocks on 128 atoms, with non-fault-tolerant preparation and postselected error detection. A bounded replacement is: the paper demonstrated finite encoded neutral-atom operations, including flagged initialization, bounded GHZ and feedforward teleportation results in 2D blocks, and separate 3D logical-gate experiments. It did not by itself establish an asymptotic threshold, sustained repeated correction at scale, or universal resource advantage.

References

• D. Bluvstein et al., “Logical quantum processor based on reconfigurable atom arrays,” Nature 626, 58–65 (2024), doi:10.1038/s41586-023-06927-3, arXiv:2312.03982.
• D. Bluvstein et al., “A fault-tolerant neutral-atom architecture for universal quantum computation,” Nature 649, 39–46 (2026), doi:10.1038/s41586-025-09848-5.
• H. Bombín, “Gauge color codes: optimal transversal gates and gauge fixing in topological stabilizer codes,” New Journal of Physics 17, 083002 (2015), doi:10.1088/1367-2630/17/8/083002, arXiv:1311.0879.
• H. Bombín and M. A. Martín-Delgado, “Topological quantum distillation,” Physical Review Letters 97, 180501 (2006), doi:10.1103/PhysRevLett.97.180501, arXiv:quant-ph/0605138.
• S. Bravyi and R. König, “Classification of topologically protected gates for local stabilizer codes,” Physical Review Letters 110, 170503 (2013), doi:10.1103/PhysRevLett.110.170503, arXiv:1206.1609.
• N. Delfosse, “Decoding color codes by projection onto surface codes,” Physical Review A 89, 012317 (2014), doi:10.1103/PhysRevA.89.012317, arXiv:1308.6207.
• A. Kubica and N. Delfosse, “Efficient color code decoders in $d\geq2$ dimensions from toric code decoders,” Quantum 7, 929 (2023), doi:10.22331/q-2023-02-21-929, arXiv:1905.07393.
• N. Lacroix et al., “Scaling and logic in the colour code on a superconducting quantum processor,” Nature 645, 614–619 (2025), doi:10.1038/s41586-025-09061-4.
• S.-H. Lee, A. Li, and S. D. Bartlett, “Color code decoder with improved scaling for correcting circuit-level noise,” Quantum 9, 1609 (2025), doi:10.22331/q-2025-01-27-1609, arXiv:2404.07482.
• D. Nigg et al., “Quantum computations on a topologically encoded qubit,” Science 345, 302–305 (2014), doi:10.1126/science.1253742, arXiv:1403.5426.
• L. Postler et al., “Demonstration of fault-tolerant universal quantum gate operations,” Nature 605, 675–680 (2022), doi:10.1038/s41586-022-04721-1, arXiv:2111.12654.
• C. Ryan-Anderson et al., “Realization of real-time fault-tolerant quantum error correction,” Physical Review X 11, 041058 (2021), doi:10.1103/PhysRevX.11.041058.