Topological Codes

A topological quantum code protects logical information through local constraints and nonlocal equivalence classes. Small regions reveal syndromes but cannot distinguish encoded states; a nontrivial logical operator must span a support that grows with the code. Errors can therefore be read geometrically as chains, their syndromes as boundaries, and undetectable logical failures as nontrivial homology classes. That common structure links quantum error correction, commuting-projector Hamiltonians, and anyon language, but it does not make their operational claims interchangeable.

This page develops that shared structure for finite-dimensional, geometrically local Pauli stabilizer codes. It explains what survives across surface, color, and related homological families, then separates active measurement-and-decoding protocols from passive Hamiltonian protection. Specific constructions, decoder thresholds, protected gates, phase classification, and hardware evidence remain with their canonical owners.

Required background. Stabilizer Formalism supplies commuting Pauli generators, projectors, normalizers, and logical cosets. CSS Codes supplies paired binary complexes and quotient-space algebra.

Helpful background. Surface Code is the principal concrete active-code family. Topological Order Preview derives the many-body local-indistinguishability and toric-Hamiltonian viewpoint used here only as a bridge.

Local Checks and Nonlocal Logical Information

Default code class and projector

Take $n$ qubits on a bounded-degree cellulation and a commuting family of Hermitian Pauli checks. Choose $r$ independent Hermitian generators $S_1,\ldots,S_r$, fix their signs so the code is their common $+1$ eigenspace, and assume that their group $\mathcal S$ does not contain $-I$. Retain those signed Hermitian representatives in projectors and Hamiltonians, but take every logical quotient, normalizer, distance, and Pauli path below in the projective Pauli group $\overline{\mathcal P}_n=\mathcal P_n/\langle iI\rangle$; global phases are not distinct errors. Use $\mathcal S$ also for the stabilizer group’s image in that quotient. The code projector and encoded dimension are

$$P=\prod_{a=1}^{r}\frac{I+S_a}{2}, \qquad \operatorname{Tr}P=2^{n-r}, \qquad k=n-r.$$

Independence matters for the displayed trace and encoded-dimension count. Multiplying the same factor for a dependent check leaves the projector and common $+1$ eigenspace unchanged but invalidates the simple rank count. The logical Pauli group is $N(\mathcal S)/\mathcal S$, where

$$N(\mathcal S) :=\{[E]\in\overline{\mathcal P}_n: ES=SE\text{ for every signed representative of }S\in\mathcal S\}.$$

Thus $N(\mathcal S)$ means the projective classes with commuting representatives—the symplectic centralizer conventionally called the Pauli normalizer—not the ordinary subgroup normalizer inside the abelian projective quotient. Thus two extended operators that differ by a stabilizer represent the same logical action.

Geometric locality adds conditions not present in an abstract stabilizer presentation: every chosen check has bounded diameter and bounded weight, and every qubit meets only a bounded number of checks as the family grows. Those conditions make local syndrome acquisition conceivable. They do not by themselves make a code topological. A family also needs a growing code scale, so that no bounded region supports a nontrivial logical operator and local operators cannot read the encoded label. This distinction is emphasized in Bombín’s structure theorem for two-dimensional topological stabilizer codes.

Object	Exact statement in the default class	What does not follow
Local check	A bounded-diameter Pauli generator $S_a$ with $S_a^2=I$	Locality alone does not imply growing distance or a threshold.
Code projector	$P=\prod_a(I+S_a)/2$ for an independent Hermitian set with fixed $+1$ code signs	A projector formula does not supply a physical Hamiltonian or measurement circuit.
Correctable region	All errors supported there satisfy Knill–Laflamme on the code space	Correctability is not the same as easy decoding.
Local indistinguishability	$PO_RP=c_R(O_R)P$ for every operator on the region	This condition alone does not prove phase stability or thermal memory.
Logical class	An element of $N(\mathcal S)/\mathcal S$	One drawn string is not a unique physical representative.
Distance	Minimum support of a nontrivial logical class	A lattice side length is not automatically the distance.
Syndrome defect	A check with nontrivial commutation bit or measured eigenvalue	A defect need not be an intrinsic material quasiparticle.
Boundary	A declared region where a compatible charge or chain may terminate	Not every edge condenses every defect type.
Parent Hamiltonian	$H_{\mathrm{code}}=-\sum_aJ_aS_a$ with declared positive couplings	The hardware need not realize this Hamiltonian.
Energy barrier	Maximum excitation cost minimized over local paths to a logical operator	A gap, distance, threshold, and thermal lifetime are different quantities.

Correctable regions and local indistinguishability

Let $R$ be a region and let $E_i,E_j$ range over operators supported in $R$. Exact correction of erasure on $R$ is equivalent to the Knill–Laflamme condition

$$P E_i^\dagger E_j P=c_{ij}P.$$

Because products $E_i^\dagger E_j$ span the operator algebra on $R$, the same content can be expressed as

$$P O_R P=c_R(O_R)P$$

for every $O_R$ supported there. Within the code space, a correctable local probe is therefore proportional to the identity: it neither distinguishes logical states nor drives a transition between them. This is the precise QEC meaning of local invisibility. Why QEC Is Possible owns the general information-disturbance and recovery theorem behind it.

For a topological family, one asks for this relation on every topologically trivial region below a scale that grows with the system. The statement may be approximate in a generic gapped phase and exact at an ideal commuting-projector fixed point. It is not, by itself, a stability theorem. Bravyi, Hastings, and Michalakis require both local indistinguishability (TQO-1) and an additional local-to-global consistency condition (TQO-2) to prove spectral stability of a frustration-free commuting-projector Hamiltonian under sufficiently weak, decaying local perturbations. Their result is a zero-temperature statement about spectral bands, not a claim that a thermal bath leaves the encoded state intact.

Distance as a geometric obstruction

The code distance is

$$d=\min_{L\in N(\mathcal S)\setminus\mathcal S}|\operatorname{supp}L|.$$

In a local topological family, nontrivial logical representatives cannot be shrunk into a bounded disk. They must connect compatible boundaries, surround a puncture, wind around a handle, form a nontrivial membrane, or realize some other global obstruction. Multiplying by local stabilizers deforms the representative without changing its logical class. The obstruction is topological; its minimum weight is also metric and combinatorial. Changing the cellulation, weights, aspect ratio, or boundary separation can change $d$ without changing the underlying homology.

This distinction prevents two common overclaims. First, an extended logical operator does not imply passive self-correction: it may be assembled one local fault at a time with only a bounded energetic cost. Second, bounded-weight checks do not imply finite rate, large distance, or efficient decoding. Those properties belong to separate layers of a code-family claim.

Chains, Boundaries, and Logical Homology

Cellular chain-complex convention

For the common homological CSS dictionary, fix a closed cellulation $\Lambda$ with no boundary at which a charge may condense, and use the binary chain complex

$$C_2\xrightarrow{\partial_2}C_1\xrightarrow{\partial_1}C_0, \qquad \partial_1\partial_2=0.$$

Place one qubit on each one-cell. In the convention used here, a $Z$ error is a chain $e\in C_1$. Vertex-supported $X$ checks detect its boundary $\partial_1e$, while a face-supported $Z$ check is a boundary $\partial_2f$. Multiplying the error by that stabilizer sends $e\mapsto e+\partial_2f$ without changing its syndrome because $\partial_1\partial_2=0$.

The undetectable closed chains are $\ker\partial_1$, and face boundaries are trivial representatives. Their quotient is

$$H_1(\Lambda;\mathbb F_2) =\frac{\ker\partial_1}{\operatorname{im}\partial_2}.$$

Nonzero classes label $Z$-type logical operators in this convention. The conjugate $X$-type operators live in the dual or cochain complex, and their commutation is the mod-two intersection pairing. This is a construction framework, not a definition of every topological code: color-code string nets, subsystem gauge operators, non-Abelian fusion spaces, and fracton operators require qualified extensions.

Syndromes as boundaries

For any Pauli error $E$, define the syndrome bit of a check by

$$S_aE=(-1)^{s_a(E)}ES_a, \qquad s_a(E)\in\mathbb F_2.$$

An ideal measurement of $S_a$ returns the eigenvalue $(-1)^{s_a(E)}$ relative to the reference code sector. In the chain picture, the collection of nonzero $X$-check bits for a $Z$ error is exactly $\partial_1e$. An open path has endpoint defects; a closed path has no such syndrome. Closure is necessary for an undetected chain, but it is not enough to make the action trivial. A contractible closed chain is the boundary of a 2-chain, hence a product of face checks and therefore a stabilizer. A noncontractible closed chain can be logical.

This is why syndrome data identify an equivalence class of possible errors, not the microscopic error itself. Local deformations and added closed cycles can leave the same boundary. Repeated circuits add a time direction and measurement faults, so the operational object becomes a spacetime detection record rather than one static boundary. Syndrome Measurement owns that circuit-level transition.

Recovery classes and homology

Let the actual error be $e$ and a decoder’s proposed recovery be $r$. Matching the observed syndrome means

$$\partial_1r=\partial_1e.$$

Consequently $e+r$ is closed. Recovery succeeds exactly when the combined chain is homologically trivial:

$$[e+r]=0\quad\text{in }H_1(\Lambda;\mathbb F_2).$$

If $[e+r]\ne0$, the recovery removes every defect yet completes a logical cycle. Dennis, Kitaev, Landahl, and Preskill make this homological ambiguity central to topological quantum memory. Bombín and Martín-Delgado develop the corresponding chain-complex construction for homological classical and quantum codes. It remains the cleanest statement of what a topological decoder is inferring: not the exact error chain, but a recovery class likely to have trivial total homology under a declared noise model.

Two recoveries may therefore fit the same syndrome and differ by a logical operator. Geometry can make one much shorter, and a decoder can use that as a statistical prior, but shortest is not synonymous with maximum likelihood under correlated, biased, circuit-level, or leakage noise. Decoder algorithms, confidence estimates, and latency remain with Decoders.

Boundaries, punctures, and defects

On a bounded surface, an error chain may terminate at a boundary that condenses its endpoint charge. If $B$ is the declared set of compatible boundary cells, the relevant logical classes are relative classes such as

$$[e]\in H_1(\Lambda,B;\mathbb F_2).$$

The relative boundary of $e$ may lie in $B$ while vanishing in the quotient. The dual Pauli sector generally uses a different compatible boundary set. Bravyi and Kitaev’s lattice-with-boundary construction formalizes this distinction.

A puncture adds a boundary component and can create new nontrivial relative classes. Moving or changing a boundary can deform logical representatives and implement operations, but only within a fully specified code-deformation protocol. A twist changes which charge labels are identified when a string crosses a defect line. These ideas share topology, yet they are not interchangeable. Surface Code owns rough/smooth patch conventions and concrete punctures; Color Codes owns colored boundaries and string nets; Fault-Tolerant Gates owns the operation-level containment conditions.

Defects, Charges, and the Anyon Dictionary

Violated checks as code excitations

The same commuting-check algebra has two readings. In an active code, $s_a(E)=1$ is a measured syndrome bit. If the checks are instead physically realized as the positive-coupling Hamiltonian

$$H_{\mathrm{code}}=-\sum_aJ_aS_a, \qquad J_a>0,$$

the same bit labels a violated local term, with ideal excitation cost

$$\Delta E(E)=2\sum_{a:s_a(E)=1}J_a.$$

An open string creates defects at its endpoints; extending the string moves them without adding excitations along the healed interior. Pair creation and annihilation give a $\mathbb Z_2$ parity or fusion rule in the associated Abelian model. This correspondence is exact for Kitaev’s toric-code fixed point. It does not show that a gate-based processor actually contains those energetic quasiparticles.

Strings, fusion, and braiding

At the toric-code fixed point, take a primal path $\gamma$ and a dual path $\gamma^\ast$. Their Pauli strings obey

$$Z(\gamma)X(\gamma^\ast) =(-1)^{I_2(\gamma,\gamma^\ast)} X(\gamma^\ast)Z(\gamma),$$

where $I_2$ is the mod-two intersection number. One crossing produces a minus sign. In the toric-code Hamiltonian, the same algebra is read as the mutual braiding phase of the endpoint charge types. Contractible closed strings act trivially on the code space; nontrivial closed or relative strings act logically; products of endpoint charges obey the corresponding conservation law.

This Abelian string dictionary is powerful but limited. Color codes carry three constrained string colors and admit string nets; the colors are not three independent toric-code copies. Non-Abelian anyons act on fusion spaces, so their braid operators are matrices rather than only intersection signs. Anyons and Braiding owns fusion channels, $F$ and $R$ data, braid-group representations, and the distinction between Abelian and non-Abelian statistics.

Engineered defects are not automatically material anyons

The phrase anyon should name a topological superselection excitation of a declared two-dimensional gapped Hamiltonian or phase. A flipped parity bit in an actively measured stabilizer circuit is more precisely a syndrome defect, or an anyon-like defect of the associated code Hamiltonian. The distinction is evidential, not merely verbal. A processor may reproduce the string algebra, fusion constraints, and programmed braids while its underlying material has no intrinsic deconfined anyons.

Conversely, discovering intrinsic anyons in a material would not by itself supply a complete fault-tolerant code. Initialization, controlled transport, readout, leakage management, non-topological operations, and active recovery still require an architecture. Topological Order owns intrinsic phase classification; Topological Quantum Computation Bridge owns the material-versus-programmed protection ledger; and Topological Qubits owns the device module and current evidence.

Active Correction and Passive Protection

Repeated measurement and decoding

An active topological memory does not wait for a Hamiltonian to remove errors. It repeatedly measures local checks, exports entropy into measurement records and reset ancillas, and uses classical inference to choose a recovery class. If $m_{a,t}\in\mathbb F_2$ is the reported bit for check $a$ in round $t$, a basic detection event is a change

$$d_{a,t}=m_{a,t}+m_{a,t-1}\pmod 2.$$

A data fault can create a pattern extended in space; a measurement fault can create a pattern extended in time. The decoder consumes the full spacetime record, not merely the last syndrome snapshot. Its output may be applied as a physical correction or recorded in a Pauli frame. In either case, success is a statement about the combined physical error and inferred recovery class.

Three claim layers built from related local constraints. At left, an open error chain has local syndrome defects at its boundary, while a closed nontrivial cycle can act logically. The active branch repeatedly measures checks, decodes the spacetime record, and updates a correction or Pauli frame. The passive branch instead assigns energies through a physical Hamiltonian and asks for the largest cost along a local path to a logical operator. Shared topology does not equate decoder performance, spectral stability, an energy barrier, or thermal lifetime.

This loop needs an architecture contract. The check circuit fixes hook errors and correlated propagation; the noise model fixes relative path likelihoods; the decoder fixes an inference rule and latency; and leakage, reset, erasure flags, and feed-forward change the record. A threshold is therefore associated with a family of circuits, decoders, and faults, not with topology alone. Threshold Theorem owns the asymptotic suppression claim, while the concrete Surface Code and Color Codes pages own their family-specific extraction and evidence.

Parent Hamiltonians and spectral gaps

The formal Hamiltonian

$$H_{\mathrm{code}}=-\sum_aJ_aS_a, \qquad J_a>0,$$

has the stabilizer code as its ground space when the chosen check signs are consistent. Because the terms commute, an eigenstate can be labeled by their eigenvalues. Flipping an accessible set of checks raises the ideal energy by twice the sum of their couplings. This turns syndrome defects into energetic excitations of the associated model.

Three qualifications are essential. First, a laboratory may measure $S_a$ with gates and ancillas without implementing the many-body interaction $-J_aS_a$. Second, an exactly solvable parent Hamiltonian is one point in a larger Hamiltonian space; persistence of its low-energy sector under generic perturbations requires a stability theorem. Third, a nonzero spectral gap is the cost of the lowest excitation, not the maximum cost along a path to a logical error.

For frustration-free, geometrically local commuting-projector Hamiltonians, Bravyi, Hastings, and Michalakis prove stability under sufficiently weak local perturbations when both TQO-1 and the local-consistency condition TQO-2 hold through a macroscopic scale. The perturbed low-energy band remains narrow and separated. That result justifies robustness to weak static perturbations within its hypotheses. It does not specify a decoder, a bath, or a finite- temperature lifetime.

Energy barriers and thermal lifetime

For the unit-coupling stabilizer Hamiltonian, assign a Pauli $E$ the excitation cost

$$\epsilon(E)=2\,\#\{a:S_aE=-ES_a\}.$$

Let a local path $\gamma=(I=E_0,E_1,\ldots,E_T=L)$ build a logical Pauli $L$ one single-qubit Pauli at a time. The logical energy barrier is

$$\Delta_{\mathrm{bar}} =\min_{L\in N(\mathcal S)\setminus\mathcal S} \min_{\gamma:I\to L} \max_t\epsilon(E_t).$$

With bounded positive couplings, one uses the corresponding weighted energy. The barrier asks whether a local fault path must cross a cost that grows with the system. It is not the final energy of $L$: a logical operator commutes with all checks and returns to the ground sector.

Bravyi and Terhal’s no-go theorem applies to a two-dimensional stabilizer Hamiltonian with bounded-range Pauli generators, bounded check incidence, bounded couplings, and open or periodic boundaries: under local-error paths whose successive operators differ by one single-qubit Pauli, at least one nontrivial logical Pauli has $\Delta_{\mathrm{bar}}=O(1)$. Their construction finds such an operator in a bounded-width strip and grows it while leaving excitations only near moving endpoints. Thus a two-dimensional surface or color code can have $d=\Theta(L)$ yet lack a growing passive barrier. The result does not obstruct active correction and does not cover every commuting-projector or subsystem Hamiltonian.

Even a diverging barrier would not, by itself, prove self-correction. The number of error paths, defect mobility, bath spectral density, boundary conditions, equilibration, and decoding protocol all affect a memory time. Passive self-correction requires a lifetime that grows with system size under a declared open-system dynamics without repeated externally controlled syndrome recovery during storage.

Distance, threshold, barrier, and lifetime are different

The layers can now be separated precisely:

• Distance is a code-space minimum support and says which errors are correctable in principle.
• Threshold is an asymptotic property of a complete active fault, extraction, decoder, and operation family.
• Spectral gap is a Hamiltonian excitation energy near the ground sector.
• Energy barrier is a minimax cost along allowed local paths to a logical operator.
• Memory lifetime is a dynamical observable under a specified bath, temperature, controls, and final recovery.

None is a numerical substitute for another. A code may have growing distance and an active threshold but a constant passive barrier. A Hamiltonian may be gapped and perturbatively stable at zero temperature yet have a lifetime that fails to grow at fixed nonzero temperature. A finite experiment can measure a logical lifetime without establishing an asymptotic threshold or a thermodynamic self-correcting phase. Terhal’s review of quantum memories develops these distinctions across code families.

Families and Dimensional Taxonomy

Toric and surface families

Kitaev’s toric code is the canonical closed-surface example: local star and plaquette checks define a commuting Hamiltonian, open strings create endpoint charges, contractible loops are stabilizers, and noncontractible primal and dual loops are logical operators. Closing the surface removes physical boundaries but leaves homology-dependent ground sectors.

Surface codes adapt this structure to bounded patches and relative homology. Compatible strings can end on selected boundaries, allowing planar encodings and code deformation. The common chain dictionary belongs here; exact qubit placement, rough and smooth conventions, repeated extraction, matching, thresholds, surgery, and resource overhead remain with Surface Code.

Color-code families

Two-dimensional color codes are local topological CSS codes on trivalent, three-face-colorable cellulations. Their logical operators can be expressed by colored strings and string nets, with relations among the color sectors. They share local indistinguishability, deformable representatives, boundary charges, and homological reasoning with surface codes, but they are not three independent copies of a surface-code patch.

Bombín and Martín-Delgado introduced the construction in topological quantum distillation. Equivalences or unfolding maps require declared ancillary and boundary hypotheses; they do not identify every finite patch, decoder, extraction circuit, or transversal gate. Color Codes retains the 2-colex incidence, seven-qubit fixture, colored boundaries, transversal Clifford audit, decoding, and evidence.

Local topological codes inside qLDPC

A stabilizer family is qLDPC when it admits bounded-weight generators and each qubit participates in only boundedly many generators. Regular surface and color-code families satisfy that sparsity definition. Topology supplies an interpretation of logical equivalence classes; qLDPC supplies a constraint on the parity-check presentation. Neither term contains the other without additional hypotheses.

In particular, abstract qLDPC constructions may use non-Euclidean Tanner graphs or long-range hardware connections. Conversely, a local commuting- projector code can be topological in the family sense while encoding only a constant number of qubits, so its asymptotic rate vanishes. Quantum LDPC Codes owns sparsity constants, Tanner graphs, product constructions, rate-distance scaling, decoder behavior, measurement schedules, and architecture evidence.

Higher-dimensional, subsystem, and non-Abelian extensions

Dimension changes the shapes available to excitations and logical operators. In the four-dimensional toric-code memory analyzed by Dennis and collaborators, both error sectors can involve extended loop-like defects, changing the thermal problem. In three dimensions, pointlike and extended sectors can coexist. Haah’s cubic code goes further: it has no arbitrarily long string logical operators. These facts show that the two-dimensional string/anyon picture is not universal; they do not, by themselves, establish a practical self-correcting memory.

Subsystem topological codes can measure gauge generators and infer stabilizers. Their gauge freedom can reduce check weight or enable gauge fixing, but local gauge generators need not fit every theorem for local commuting stabilizer Hamiltonians. Subsystem Codes owns the protected-factor algebra, gauge center, bare and dressed logicals, gauge-syndrome schedules, Bacon–Shor construction, and subsystem-specific locality bounds. Non-Abelian topological codes encode in fusion spaces and may use braids, fusion, and charge measurements. Their operator algebra is not exhausted by binary homology or the Pauli normalizer. Topological Quantum Computation owns that executable computation model.

Family or setting	Shared topological-code structure	Distinct owner or limitation
Toric code on a closed surface	Local commuting checks, endpoint charges, and noncontractible logical loops	Topological Order Preview owns the Hamiltonian and phase derivation.
Planar surface code	Relative chains, compatible boundaries, and active syndrome recovery	Surface Code owns patches, circuits, decoding, thresholds, and surgery.
Two-dimensional color code	Local checks, colored strings, deformable logical classes, and boundaries	Color Codes owns the 2-colex construction, gates, decoding, and evidence.
Euclidean local commuting-projector code	Correctable regions and conditional geometric tradeoffs	Not every model is a Pauli stabilizer code or an active architecture.
Abstract qLDPC code	Bounded check weight and bounded qubit degree	qLDPC need not have Euclidean locality, homology, or intrinsic anyons.
Subsystem topological code	Nonlocal protected subsystem with local gauge information	Stabilizer-Hamiltonian no-go theorems do not automatically transfer.
Higher-dimensional or fracton setting	Global logical structure with dimension-dependent excitation geometry	The 2D string dictionary and thermal conclusions are not universal.
Non-Abelian fusion-space code	Locally inaccessible information and topological charge operations	Anyon data and braid computation require a fusion-category description.

Tradeoffs and Protected Operations

The two-dimensional rate-distance tradeoff

Bravyi, Poulin, and Terhal consider $n$ bounded-dimensional particles on a two-dimensional Euclidean lattice whose code space is the common eigenspace of bounded-range commuting projectors. If $k=\log_2\dim\mathcal C$ and $d$ is the exact distance, they prove

$$kd^2\le Cn,$$

where $C$ depends on local dimension and interaction range, not on system size. A family with nonzero asymptotic rate $k/n$ in this model therefore has $d=O(1)$; a family encoding at least one qubit has $d=O(\sqrt n)$. Disjoint surface-code patches saturate the two-dimensional scaling up to constants.

The hypotheses carry the meaning. This tradeoff uses bounded-range Euclidean geometry, not only sparse parity checks. It covers commuting-projector codes more generally than stabilizers, but it does not cover arbitrary subsystem codes or non-Euclidean qLDPC cellulations. It is therefore incorrect to use $kd^2=O(n)$ as a universal bound on every qLDPC family.

Self-correction and dimensional limitations

The two-dimensional rate-distance bound and the constant-barrier no-go theorem answer different questions. The first limits how much exact quantum information can coexist with geometric distance. For a two-dimensional stabilizer Hamiltonian with bounded-range generators, bounded qubit incidence, and unit or uniformly bounded check couplings, the second shows that at least one logical Pauli can be assembled without a growing energy barrier. Neither prohibits a threshold for active error correction.

Higher dimensions can evade the particular string-endpoint mechanism because defects may themselves be extended. Yet dimension alone is not a self- correction theorem. A candidate must specify its Hamiltonian, allowed local errors, boundaries, bath generator, temperature regime, decoder, and thermodynamic scaling. Entropic paths can undermine a large energetic cost, and a finite-size crossover can imitate asymptotic growth. The stable claim is conditional: two-dimensional local stabilizer Hamiltonians fail the stated barrier test, while higher-dimensional and nonstandard models require separate analysis.

Locality-preserving logical gates

Define the Clifford hierarchy recursively by

$$\mathcal C_1=\mathcal P, \qquad \mathcal C_j=\{U:UPU^\dagger\in\mathcal C_{j-1} \text{ for every }P\in\mathcal P\}.$$

Bravyi and König consider a $D$-dimensional stabilizer-code family with bounded-range generators of range $\xi$, growing distance $d$, and a codespace-preserving depth-$h$ local circuit whose gates have range $r$. When

$$\xi,\;hr\ll d^{1/D},$$

the induced logical unitary lies in $\mathcal C_D$. Thus a qualifying two-dimensional circuit implements a logical Clifford operation, while a three-dimensional circuit can reach the third hierarchy level. The classification does not directly cover magic-state injection, adaptive measurements, growing-depth or long-range protocols, arbitrary subsystem codes, or non-Abelian fusion-space computation. It limits one protected mechanism rather than every route to universality. Fault-Tolerant Gates owns the proof tools and operational workarounds.

Auditing a Topological-Code Claim

A claim-layer audit

A trustworthy claim names the layer being tested and the record needed to support it. Passing a lower layer is often necessary for a higher one, but it is rarely sufficient.

Claim layer	Minimum supporting record	Invalid shortcut
Code-space algebra	Independent checks, signs, rank, logical quotient, and exact convention	A lattice drawing proves neither $k$ nor $d$.
Syndrome geometry	Check-to-defect map, boundaries, chain convention, and recovery equivalence	Matching endpoint locations reconstructs the microscopic error.
Active decoding	Noise and circuit model, repeated record, decoder, failure rule, and latency	Homology alone supplies a practical decoder.
Threshold	Growing family under one declared architecture contract and logical scaling	One finite below-physical logical error rate proves a threshold.
Spectral gap	A physical Hamiltonian, spectrum, boundary conditions, and size scaling	Measured stabilizers imply that the device realizes $H_{\mathrm{code}}$.
Perturbative stability	Locality, TQO-1, TQO-2, perturbation norm and range, and spectral bands	Local indistinguishability alone proves a stable phase.
Energy barrier	Allowed local paths, excitation energies, couplings, and minimax scaling	Large distance implies a growing barrier.
Thermal lifetime	Bath dynamics, temperature, controls, final recovery, and size scaling	A gap or barrier value is itself a memory time.
Protected logical gates	Code family, dimension, range, depth, preservation, leakage, and logical channel	“Topological” implies a universal native gate set.

The audit also prevents category errors between intrinsic and engineered systems. A simulator can validate an anyon algebra without demonstrating a material topological phase. A material can exhibit topological order without providing addressable logical gates. An actively corrected code can have topological logical classes without passive thermal protection.

Canonical handoffs

Use the common dictionary here, then follow the claim to its owner:

• Stabilizer Formalism and CSS Codes own the general algebra.
• Surface Code and Color Codes own their concrete families.
• Quantum LDPC Codes owns sparsity and asymptotic constructions; Decoders owns inference algorithms.
• Topological Order Preview and Topological Order own the many-body phase statements.
• Anyons and Braiding owns fusion and braid data, while Topological Quantum Computation owns executable fusion-space protocols.

The words local, topological, protected, and fault tolerant should never stand alone as evidence. Each needs an object, a model, a scaling limit, and a failure criterion.

Exercises

1. Verify a stabilizer projector

On three qubits, take $S_1=Z_1Z_2$ and $S_2=Z_2Z_3$. Verify that

$$P=\frac{1}{4}(I+S_1)(I+S_2)$$

is an orthogonal projector. Find its trace, the number of encoded qubits, a basis for its image, and one choice of logical $X$ and $Z$. Explain which step would fail if $S_2$ were replaced by the dependent generator $S_1$.

Solution

The checks commute and satisfy $S_a^2=I$, so each $(I+S_a)/2$ is an orthogonal projector. Commuting projectors multiply to a projector:

$$P^2=\frac{1}{16}(I+S_1)^2(I+S_2)^2=P.$$

In the expansion $I+S_1+S_2+S_1S_2$, only the identity has nonzero trace. Therefore $\operatorname{Tr}P=8/4=2$, so $k=\log_2 2=1$. The simultaneous $+1$ basis is $\{|000\rangle,|111\rangle\}$. One logical choice is $\overline X=X_1X_2X_3$ and $\overline Z=Z_1$; both commute with the checks, neither is a stabilizer, and they anticommute.

If the two displayed generators were identical, the common eigenspace would still be well defined, but the rank would be one rather than two. Treating the duplicate as independent would predict the wrong trace and encoded dimension. Indeed, $\frac14(I+S_1)^2=\frac12(I+S_1)$ is still the correct orthogonal projector, now with trace four and $k=2$.

2. Read a syndrome as a boundary

Let one square face have oriented edge labels $e_{12},e_{23},e_{34},e_{41}$, with binary coefficients so orientation signs are irrelevant. For the error chain $e=e_{12}+e_{23}$, compute $\partial_1e$. Then add the face boundary $b=\partial_2f=e_{12}+e_{23}+e_{34}+e_{41}$ and verify that $e'=e+b$ has the same syndrome. Are the two errors logically distinct in a simply connected patch containing that face?

Solution

Each edge has the sum of its endpoint vertices as boundary. The intermediate vertex cancels over $\mathbb F_2$:

$$\partial_1e=(v_1+v_2)+(v_2+v_3)=v_1+v_3.$$

Adding the four-edge face boundary leaves $e'=e_{34}+e_{41}$, whose boundary is likewise

$$(v_3+v_4)+(v_4+v_1)=v_1+v_3.$$

Equivalently, $\partial_1(e+b)=\partial_1e+\partial_1\partial_2f=\partial_1e$. The two paths join the same defects on opposite sides of the face. Their difference is the face boundary, which represents a $Z$ stabilizer in the declared convention. In a simply connected patch where that face is present and no relevant puncture or condensing boundary intervenes, they are the same error class, not distinct logical operators. The calculation illustrates why a syndrome fixes endpoints but not a unique chain.

3. Distinguish two recovery classes

On an annular cellulation, let an error chain $e$ have endpoint syndrome $\partial e=a+b$. Let $r$ be a recovery with the same endpoints and let $\ell$ be a closed chain winding once around the hole. Assume no boundary condenses the relevant endpoint charge and $[\ell]\ne0$ in the declared logical homology. Define $r'=r+\ell$. Show that $r$ and $r'$ fit the same syndrome. If $[e+r]=0$, what happens when $r'$ is applied instead? Why can no syndrome-only rule distinguish the two candidates without a prior over error classes?

Solution

Because $\partial\ell=0$,

$$\partial r'=\partial r+\partial\ell=a+b.$$

Both candidates therefore remove the observed endpoint defects. Their combined classes with the error differ by the nontrivial annular cycle:

$$[e+r']=[e+r+\ell]=[e+r]+[\ell]=[\ell]\ne0.$$

Under the premise $[e+r]=0$, applying $r$ succeeds and applying $r'$ completes a logical loop around the hole. The final syndrome is trivial in both cases. The measurement record contains the boundary of the error, not its homology class. A decoder must therefore combine the syndrome with a model of which chains or spacetime histories are likely. Minimum weight is one such rule for some independent-noise settings, but correlations, bias, degeneracy, and circuit faults can change the relevant likelihoods.

4. Use relative homology at a boundary

Consider a planar patch with two boundary components collected into a set $B$, and suppose the declared $Z$-type endpoint charge can condense on $B$. A chain $c$ joins one component of $B$ to the other. Explain why $c$ is closed as a relative chain even though its ordinary boundary is nonzero. Under what condition does it represent a logical operator? What must be reconsidered for the conjugate $X$ sector?

Solution

Ordinarily, $\partial c=b_1+b_2$ with $b_1,b_2\in B$. In the relative complex $C_\bullet(\Lambda,B)$, chains wholly in $B$ are quotiented out, so this boundary vanishes. Hence $c$ defines a class in $H_1(\Lambda,B;\mathbb F_2)$.

It is logical only if that relative class is nonzero: $c$ must not be deformable, after adding face boundaries and chains within $B$, into the trivial class. A shortest path between the two compatible components is then a candidate logical representative, and its minimum support contributes to $d_Z$ in this convention. Merely ending on the physical edge is insufficient; the endpoint charge must be one that the declared boundary condenses.

The conjugate $X$ sector is represented in the dual or cochain complex and usually has a different compatible boundary set $B^\ast$. Reusing $B$ without checking the boundary type can assign the wrong endpoints, logical classes, and distance.

5. Audit the anyon dictionary

A gate-based processor repeatedly measures commuting checks. A string of single-qubit gates flips two endpoint checks, the endpoints are moved around one another by further gates, and the final logical measurement shows the expected minus sign from an odd primal-dual crossing. Classify what this demonstrates. Which additional claim would require a physically realized Hamiltonian, and which would require evidence for an intrinsic material phase?

Solution

The experiment demonstrates controlled syndrome defects and the string- operator algebra of the encoded model. If the gates reproduce

$$ZX=(-1)^{I_2}XZ$$

for one crossing, the observed sign validates the associated Abelian mutual- statistics rule within that programmed code space. Calling the endpoints anyon-like syndrome defects, or anyons of the associated code Hamiltonian, states the result accurately.

A literal energetic-excitation claim requires evidence that a Hamiltonian such as $H_{\mathrm{code}}=-\sum_aJ_aS_a$ is physically present, together with its spectrum and preparation regime. A claim of intrinsic material anyons is stronger: it needs a gapped many-body phase, deconfined superselection sectors, and fusion or braiding data robust under the relevant phase equivalence and material controls. Programmed gates can simulate that algebra without the hardware material possessing the phase. None of these results alone supplies a decoder threshold or a complete fault-tolerant architecture.

6. Separate active and passive protection

Classify each observation as evidence about distance, an active threshold, a spectral gap, an energy barrier, or a thermal lifetime: (a) the lightest logical operator has weight $L$; (b) logical error per cycle decreases from distance five to seven under one repeated circuit and decoder; (c) the first excited eigenstate lies energy $\Delta$ above a degenerate ground space; (d) one local path to a logical operator never exceeds four violated checks; (e) the autocorrelation time grows with $L$ under a specified Davies generator.

Solution

(a) is a distance statement, $d=L$, for the declared metric and logical sector. It says nothing by itself about measurement faults or energy.

(b) is finite-size evidence for active suppression under that circuit, noise model, decoder, and timing contract. Additional sizes and asymptotic analysis are needed for a threshold claim.

(c) is a spectral-gap observation. It concerns low-energy eigenvalues, not a path to a logical operator or a bath-driven lifetime.

(d) upper-bounds the energy barrier by a constant proportional to four check penalties. Even if the final logical operator has weight $L$, local faults can build it without a growing maximum cost.

(e) is direct dynamical evidence about a memory timescale for the stated bath and observable. Its interpretation still depends on temperature, boundaries, controls, accessible sizes, and the final decoding rule. A growing lifetime is the relevant passive-memory evidence, but finite-size growth does not alone prove thermodynamic self-correction.

7. Apply locality theorems with hypotheses

Evaluate four claims. (i) A bounded-local-dimension family defined by bounded-range commuting projectors on a two-dimensional Euclidean lattice has $k=0.1n$ and $d=\sqrt n$. (ii) A hyperbolic qLDPC family of bounded check weight is said to violate $kd^2=O(n)$. (iii) The unit-coupling canonical Hamiltonian of a two-dimensional stabilizer code with bounded-range generators, bounded check incidence, and $d=\Theta(L)$ is declared passively self-correcting because its logical strings are long. (iv) A depth-$h$, range-$r$ unitary on a growing-distance two-dimensional stabilizer family with generator range $\xi$ and $\xi,hr\ll d^{1/2}$ implements a logical $T$ gate while preserving the code space.

Solution

(i) is impossible under the Bravyi–Poulin–Terhal hypotheses. The claimed parameters give $kd^2=0.1n^2$, which cannot be bounded by $Cn$ for a size-independent $C$ and therefore contradict the theorem’s conclusion.

(ii) is not established. Bounded check weight is qLDPC sparsity, whereas the theorem assumes bounded-range embedding in a two-dimensional Euclidean lattice. Hyperbolic or nonlocal connectivity removes that premise, so the formula cannot be invoked without another argument.

(iii) conflates distance with an energy barrier. Under the local-generator and bounded-incidence assumptions, Bravyi–Terhal guarantee at least one logical Pauli path with $O(1)$ barrier. Active correction remains possible, but the canonical Hamiltonian is not passively self-correcting on that basis.

(iv) conflicts with Bravyi–König when the circuit range and depth satisfy $\xi,hr\ll d^{1/2}$. The logical action must be Clifford, while $T$ is in the third hierarchy level and is not Clifford. Magic-state injection, adaptive measurement, long-range gates, or growing depth could evade this particular mechanism, but each changes the claim and must be declared.

8. Repair an overclaimed architecture statement

Rewrite the following claim into a defensible ledger:

Our bounded-weight topological qLDPC code has anyons, a constant gap, and distance 15. It is therefore below threshold, self-correcting, and supports universal topologically protected gates on any hardware.

Identify at least six missing hypotheses or records and route each to the appropriate canonical topic.

Solution

A defensible statement is: “We specify a finite stabilizer code with bounded-weight checks and distance 15. In the associated parent Hamiltonian, declared check violations have an anyon-like string interpretation and the finite spectrum has a stated gap. These are code-algebra and Hamiltonian properties only.”

At least the following records remain necessary:

1. Geometric locality and qubit degree: qLDPC sparsity does not establish a Euclidean topological family; Quantum LDPC Codes owns that distinction.
2. Charge model: intrinsic anyons require a physical phase; Anyons and Braiding and Topological Order own that evidence.
3. Extraction circuit and noise model: syndrome measurement must be operationally specified.
4. Decoder and scaling: a threshold needs a growing family and decreasing logical error under one full contract; Decoders and Threshold Theorem own those claims.
5. Barrier and bath dynamics: a constant gap and distance 15 do not prove a growing energy barrier or thermal lifetime.
6. Logical-gate mechanism: dimension, depth, range, adaptivity, leakage, and code preservation must be stated; Fault-Tolerant Gates owns the restriction and workaround analysis.
7. Hardware mapping: connectivity, control, measurement, reset, and resources belong to the relevant hardware and resource-estimation pages.

References

• H. Bombín, “Structure of 2D topological stabilizer codes,” Communications in Mathematical Physics 327, 387–432 (2014), doi:10.1007/s00220-014-1893-4, arXiv:1107.2707.
• H. Bombín and M. A. Martín-Delgado, “Homological error correction: classical and quantum codes,” Journal of Mathematical Physics 48, 052105 (2007), doi:10.1063/1.2731356, arXiv:quant-ph/0605094.
• 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, M. B. Hastings, and S. Michalakis, “Topological quantum order: stability under local perturbations,” Journal of Mathematical Physics 51, 093512 (2010), doi:10.1063/1.3490195, arXiv:1001.0344.
• S. B. Bravyi and A. Y. Kitaev, “Quantum codes on a lattice with boundary,” (1998), arXiv:quant-ph/9811052.
• 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.
• S. Bravyi, D. Poulin, and B. M. Terhal, “Tradeoffs for reliable quantum information storage in 2D systems,” Physical Review Letters 104, 050503 (2010), doi:10.1103/PhysRevLett.104.050503, arXiv:0909.5200.
• S. Bravyi and B. M. Terhal, “A no-go theorem for a two-dimensional self-correcting quantum memory based on stabilizer codes,” New Journal of Physics 11, 043029 (2009), doi:10.1088/1367-2630/11/4/043029, arXiv:0810.1983.
• E. Dennis, A. Kitaev, A. Landahl, and J. Preskill, “Topological quantum memory,” Journal of Mathematical Physics 43, 4452–4505 (2002), doi:10.1063/1.1499754, arXiv:quant-ph/0110143.
• J. Haah, “Local stabilizer codes in three dimensions without string logical operators,” Physical Review A 83, 042330 (2011), doi:10.1103/PhysRevA.83.042330, arXiv:1101.1962.
• A. Y. Kitaev, “Fault-tolerant quantum computation by anyons,” Annals of Physics 303, 2–30 (2003), doi:10.1016/S0003-4916(02)00018-0, arXiv:quant-ph/9707021.
• B. M. Terhal, “Quantum error correction for quantum memories,” Reviews of Modern Physics 87, 307–346 (2015), doi:10.1103/RevModPhys.87.307, arXiv:1302.3428.