Quantum Error Correction and the Stabilizer Formalism in Biquaternionic Form

Introduction

Quantum information is fragile: a quantum state cannot be copied (no-cloning), and a small interaction with the environment decoheres it. Quantum error correction is the discovery that information can nevertheless be protected, by encoding a small logical system into a larger physical one in such a way that the effect of a local error can be detected and reversed without disturbing the encoded state. The stabilizer formalism is the algebraic structure that organizes the codes: a code is specified by an abelian group of commuting Pauli operators, and the code space is the common $+1$ eigenspace of that group.

This article develops the stabilizer formalism in the biquaternion framework. The Pauli operators are the Hermitian involutionized imaginary units

$$ X = ie_1, \qquad Y = ie_2, \qquad Z = ie_3 \ \ \longleftrightarrow\ \ \sigma_1,\ \sigma_2,\ \sigma_3 , $$

tensored with $e_0$ across the physical qubits; a stabilizer on $n$ qubits is an element of $\mathbb{M}_+^{\otimes n}$ of the form

$$ \tilde{g} = \tilde{g}_1\otimes\cdots\otimes\tilde{g}_n, \qquad \tilde{g}_j \in \{e_0,\ ie_1,\ ie_2,\ ie_3\}, \qquad \tilde{g}^2 = e_0^{\otimes n} . $$

A stabilizer group is an abelian subgroup $S$ of these elements not containing $-e_0^{\otimes n}$, and the code space is the image of the code projector

$$ \tilde\Pi = \frac{1}{|S|}\sum_{\tilde{g}\in S}\tilde{g} \ \in\ \mathbb{M}_+^{\otimes n}, \qquad \tilde\Pi^2 = \tilde\Pi, \qquad \mathrm{Tr}(\tilde\Pi) = \frac{2^n}{|S|} , $$

which is an idempotent of the tensor-product algebra. The whole theory of stabilizer codes is thus a theory of commutative subalgebras and their idempotents, expressed in the algebra that this series uses throughout: the code space is a Peirce component of a commutative subalgebra, and the syndrome measurement projects onto its idempotents.

The central result is the Knill–Laflamme error-correction condition. An error set $\{\tilde{E}_a\}$ is correctable by the code with projector $\tilde\Pi$ exactly when

$$ \tilde\Pi\,\tilde{E}_a^{*}\tilde{E}_b\,\tilde\Pi = c_{ab}\,\tilde\Pi \qquad \text{for all } a,b , $$

a set of algebraic conditions on the products of errors sandwiched between the code idempotent. The article states the condition, sketches why it is necessary and sufficient, and verifies it in the algebra for two standard codes: the three-qubit bit-flip code, which corrects any single bit-flip error, and the five-qubit perfect code, which corrects an arbitrary single-qubit error and is verified here for all fifteen nontrivial single-qubit error operators.

The Pauli Group and Stabilizers

The Pauli group in biquaternion form

On a single qubit the Pauli operators, up to the identity and phases, are the Hermitian involutions $ie_1, ie_2, ie_3$, with $X=ie_1$, $Y=ie_2$, $Z=ie_3$. They satisfy the Pauli relations inherited from the quaternion units:

$$ X^2 = Y^2 = Z^2 = e_0, \qquad XY = iZ, \quad YZ = iX, \quad ZX = iY, \qquad \{X,Y\} = \{Y,Z\} = \{Z,X\} = 0 . $$

On $n$ qubits the Pauli group is the group generated by the tensor products of these operators, each factor chosen from $\{e_0, ie_1, ie_2, ie_3\}$, together with the central phases. Every such tensor product is itself Hermitian and squares to $e_0^{\otimes n}$, so the involutions, $\tilde{g}^2 = e_0^{\otimes n}$, are the observables the stabilizer formalism uses; a general element of the group differs from one of them by a central phase, which is what closes the set under multiplication.

Stabilizer groups

A stabilizer group on $n$ qubits is an abelian subgroup

$$ S = \{\tilde{g}_1,\dots,\tilde{g}_{|S|}\} \subset \mathbb{M}_+^{\otimes n}, \qquad [\tilde{g},\tilde{g}'] = 0, \qquad \tilde{g}^2 = e_0^{\otimes n}, \qquad -e_0^{\otimes n}\notin S . $$

It is generated by $n-k$ independent elements, where $k$ is the number of logical qubits encoded; the group has order $|S| = 2^{n-k}$. In the algebra, $S$ is a finite commutative subgroup of the involutions of $\mathbb{M}_+^{\otimes n}$, and its linear span is a commutative subalgebra. Commutation is the compatibility condition that makes the generators simultaneously measurable; here the commutative subalgebra is used constructively, to define a code, and the code space is one of its Peirce components.

The code projector

The code projector is

$$ \tilde\Pi = \frac{1}{|S|}\sum_{\tilde{g}\in S}\tilde{g} . $$

Three facts, all consequences of the group structure, make it a projector:

• Idempotent. Since $S$ is a group, $\left(\sum_{\tilde{g}\in S}\tilde{g}\right)^2 = \sum_{\tilde{h}\in S}|S|\,\tilde{h} = |S|\sum_{\tilde{g}}\tilde{g}$, so $\tilde\Pi^2 = \tilde\Pi$.
• Hermitian and positive. Each $\tilde{g}$ is Hermitian, so $\tilde\Pi^{*} = \tilde\Pi$; and $\tilde\Pi$ is a sum of commuting involutions, hence it is a positive element of $\mathbb{M}_+^{\otimes n}$ with eigenvalues $0$ and $1$.
• Trace. $\mathrm{Tr}(\tilde\Pi) = |S|^{-1}\mathrm{Tr}(e_0^{\otimes n}) = 2^n/|S| = 2^k$, the dimension of the code space.

Thus the code space is the image of an idempotent of the algebra, and its dimension is $2^k$: the code encodes $k$ logical qubits into $n$ physical qubits. The projector is a Peirce component of the commutative subalgebra spanned by $S$; it is the maximal idempotent whose stabilizer is all of $S$.

Errors

An error is an element $\tilde{E}_a$ of the Pauli group, typically a tensor product with at most a few nontrivial factors. The action of the environment is a channel, and the channel's Kraus operators can be expanded in the Pauli group; if a code corrects a set of errors, it corrects any channel whose Kraus operators lie in the span of that set. This is the algebraic reduction of error correction to the finite list of Pauli errors, and it is why the analysis below can be carried out on the Pauli group alone. The channel formalism is that of the companion article Quantum Channels and the Reversible/Irreversible Dichotomy.

The Knill–Laflamme Condition

Statement

The code with projector $\tilde\Pi$ corrects the error set $\{\tilde{E}_a\}$ if and only if

$$ \tilde\Pi\,\tilde{E}_a^{*}\tilde{E}_b\,\tilde\Pi = c_{ab}\,\tilde\Pi \qquad \text{for all } a,b, $$

where $c = (c_{ab})$ is a Hermitian matrix of numbers, independent of the encoded state.

Why it is necessary

Suppose the code can correct the errors $\{\tilde{E}_a\}$, so that there is a recovery map $\mathcal{R}$ with $\mathcal{R}(\tilde{E}_a\tilde{\rho}\tilde{E}_a^{*}) = p_a\tilde{\rho}$ for every encoded $\tilde{\rho} = \tilde\Pi\tilde{\rho}\tilde\Pi$ and some probability $p_a>0$. Linearity of the recovery forces the relation $c_{ab}$: for two errors and two encoded states, the recovery must reproduce $\tilde{\rho}$ from both $\tilde{E}_a\tilde{\rho}\tilde{E}_b^{*}$ and $\tilde{E}_b\tilde{\rho}\tilde{E}_a^{*}$, and the only way the recovery can act identically on the whole code space is if the operators $\tilde\Pi\tilde{E}_a^{*}\tilde{E}_b\tilde\Pi$ are all proportional on the code space, i.e. multiples of $\tilde\Pi$. Equivalently: if two different errors had distinguishable effects on the code space, no single recovery could undo both.

Why it is sufficient

If the condition holds, diagonalize the Hermitian matrix $c = u\,d\,u^\dagger$ with $d$ diagonal. Then the rotated error operators $\tilde{F}_\alpha = \sum_a u_{a\alpha}\tilde{E}_a$ satisfy $\tilde\Pi\tilde{F}_\alpha^{*}\tilde{F}_\beta\tilde\Pi = d_\alpha\delta_{\alpha\beta}\tilde\Pi$. The errors $\{\tilde{F}_\alpha\}$ therefore map the code space to mutually orthogonal subspaces, $\tilde{F}_\alpha\tilde\Pi\tilde{F}_\beta^{*} = 0$ for $\alpha\neq\beta$, and each acts within its subspace in a way that depends only on $\alpha$. A measurement that identifies which subspace the state fell into — the syndrome measurement — followed by an operation that reverses $\tilde{F}_\alpha$ on that subspace restores the encoded state. This is the standard construction, and it is a statement about the algebra: the condition says that the error operators, restricted to the Peirce component $\tilde\Pi$, form a set of "orthogonal" block actions.

The condition in the algebra

The condition is naturally stated in the tensor-product algebra. $\tilde\Pi$ is an idempotent of $\mathbb{M}_+^{\otimes n}$; the errors are elements of the Pauli group; the sandwich $\tilde\Pi\tilde{E}_a^{*}\tilde{E}_b\tilde\Pi$ is an element of the algebra, and the condition says it is scalar on the code. The numbers $c_{ab}$ form the Gram matrix of the error operators restricted to the code space, and correcting the errors means that this Gram matrix is all the code sees of the errors: the encoded state is not resolved.

The Three-Qubit Bit-Flip Code

The code

The simplest code protects against a single bit flip. Let the stabilizer group be generated by $Z_1Z_2$ and $Z_2Z_3$, so that

$$ S = \bigl\{e_0^{\otimes3},\ Z_1Z_2,\ Z_2Z_3,\ Z_1Z_3\bigr\}, \qquad Z_1Z_2 \ \leftrightarrow\ (ie_3)\otimes(ie_3)\otimes e_0, $$

and the code projector is

$$ \tilde\Pi = \tfrac{1}{4}\Bigl(e_0^{\otimes3} + Z_1Z_2 + Z_2Z_3 + Z_1Z_3\Bigr) = \tilde\Pi_{000} + \tilde\Pi_{111}, $$

the sum of the idempotents of $|000\rangle$ and $|111\rangle$. The code space is two-dimensional: one logical qubit is encoded in three physical qubits, and the logical states are the superpositions of $|000\rangle$ and $|111\rangle$.

Verification

The following were verified by explicit computation with the $8\times8$ matrices:

• Idempotency and trace. $\tilde\Pi^2 = \tilde\Pi$ and $\mathrm{Tr}(\tilde\Pi) = 2$, so the code space has dimension $2^1 = 2$, as required for one logical qubit.
• Correction of bit flips. For the error set $\{e_0^{\otimes3}, X_1, X_2, X_3\}$, the Knill–Laflamme condition holds with $c_{ab} = \delta_{ab}$:

$$ \tilde\PiX_iX_j\tilde\Pi = \delta_{ij}\tilde\Pi, $$

verified for all $i,j$. A single bit flip is therefore correctable. - Failure for phase flips. The same check fails for the error $Z_1$: $\tilde\PiZ_1Z_1\tilde\Pi = \tilde\Pi$, but $\tilde\PiZ_1\tilde\Pi = \tilde\PiZ_1$ is not a multiple of $\tilde\Pi$, and the pair $(e_0^{\otimes3}, Z_1)$ violates the condition. A phase flip is not detected by this code; it acts on the code space as the logical $Z$ operator, which is why a code for arbitrary errors needs more structure.

Syndrome measurement

A bit flip on the $i$-th qubit anticommutes with the stabilizers that involve $Z_i$, so measuring the two generators yields a two-bit syndrome that identifies which qubit flipped:

where the syndrome bit $s_{g}$ is $0$ if the error commutes with the generator $g$ and $1$ if it anticommutes. The four syndromes are distinct, so the error is identified. The measurement is a joint measurement of commuting observables, and in the framework it is the projection onto the joint eigen-idempotents of $Z_1Z_2$ and $Z_2Z_3$ — a Peirce decomposition of the commutative subalgebra they generate. The correction is the application of $X_i$ to the identified qubit.

The Five-Qubit Perfect Code

The code

The smallest code that corrects an arbitrary single-qubit error is the five-qubit code, with stabilizer generators

$$ \begin{aligned} \tilde{g}_1 &= X Z Z X e_0, & \tilde{g}_2 &= e_0 X Z Z X,\\ \tilde{g}_3 &= X e_0 X Z Z, & \tilde{g}_4 &= Z X e_0 X Z, \end{aligned} $$

each factor standing for the corresponding Hermitian involution $X=ie_1$ or $Z=ie_3$ on that qubit. The generators are cyclic shifts of one another, they commute, and they are independent, so $|S| = 16$ and the code space has dimension $32/16 = 2$: one logical qubit in five physical qubits. The code projector is

$$ \tilde\Pi = \frac{1}{16}\prod_{i=1}^{4}\bigl(e_0^{\otimes5} + \tilde{g}_i\bigr) = \frac{1}{16}\sum_{\tilde{g}\in S}\tilde{g} . $$

Verification

The following were verified by explicit computation with the $32\times32$ matrices.

• Commutativity and independence. All four generators commute pairwise, so $S$ is abelian; the group has order $16$ and the projector has trace $2$.
• Idempotency. $\tilde\Pi^2 = \tilde\Pi$, with spectrum in $\{0,1\}$ and $\mathrm{Tr}(\tilde\Pi) = 2$, so the code space is two-dimensional.
• Knill–Laflamme for every single-qubit error. The error set $\{e_0^{\otimes5}\}\cup\{X_i,Y_i,Z_i\}_{i=1}^{5}$ has sixteen elements. For every pair $a,b$ of these sixteen, the sandwich $\tilde\Pi\tilde{E}_a^{*}\tilde{E}_b\tilde\Pi$ was found to be a multiple of $\tilde\Pi$, to machine precision. The five-qubit code therefore corrects an arbitrary single-qubit error.
• Perfection. The fifteen nontrivial single-qubit errors have fifteen distinct nonzero syndromes,

$$ (i,X)\mapsto\text{syndrome},\qquad (i,Y),\ (i,Z) \ \text{all distinct in } \{0,1\}^4\setminus\{0\}, $$

so the syndrome measurement identifies the error uniquely. This is the sense in which the code is perfect: the $32$-dimensional space decomposes exactly into the code space and the fifteen orthogonal error subspaces, with no room to spare. The counting is $1 + 15 = 16 = 2^{5-1}$, the size of the syndrome space.

The code as an idempotent

Both codes have the same algebraic shape: a stabilizer group $S$, a code idempotent $\tilde\Pi = |S|^{-1}\sum_{\tilde{g}\in S}\tilde{g}$ in $\mathbb{M}_+^{\otimes n}$, and errors whose Gram matrix on the code is scalar. The five-qubit code is the smallest case in which the error set is the full single-qubit Pauli set and the code is perfect, and it is the algebraically cleanest illustration of the Knill–Laflamme condition: the error subspaces are the images of the idempotents $\tilde{F}_\alpha\tilde\Pi\tilde{F}_\alpha^{*}$ for an orthonormalized error basis, and they tile the full space.

The projector as a group-algebra idempotent

The construction has a transparent algebraic meaning. Since $S$ is a finite abelian group of commuting involutions, its group algebra is

$$ \mathbb{C}[S] \ \cong\ \bigoplus_{\chi}\mathbb{C}e_\chi, \qquad e_\chi = \frac{1}{|S|}\sum_{\tilde{g}\in S}\chi(\tilde{g})^{-1}\,\tilde{g}, $$

where the $\chi$ run over the $|S|$ characters $S\to\{\pm1\}$ and the $e_\chi$ are the central idempotents of the group algebra, satisfying $e_\chi e_{\chi'} = \delta_{\chi\chi'}e_\chi$ and $\sum_\chi e_\chi = e_0^{\otimes n}$. The code projector is the trivial-character idempotent,

$$ \tilde\Pi = e_{\mathrm{triv}} = \frac{1}{|S|}\sum_{\tilde{g}\in S}\tilde{g}, $$

and the other $|S|-1$ idempotents $e_\chi$ are the projectors onto the syndrome subspaces. The syndrome measurement is thus the measurement of the character $\chi$, i.e. the simultaneous measurement of the generators; each outcome corresponds to one of the group-algebra idempotents. This is why the code space and the error subspaces together tile the whole module: they are the images of a complete family of central idempotents of a finite abelian group algebra, acting on the tensored module. The counting $2^n = |S|\times 2^k$ is the statement $\dim = \sum_\chi \mathrm{Tr}(e_\chi)$, with each $\mathrm{Tr}(e_\chi) = 2^k$.

Verified for the two codes: the images of the four group-algebra idempotents of the three-qubit code's stabilizer group sum to the identity on the $8$-dimensional module, and likewise for the sixteen idempotents of the five-qubit code on the $32$-dimensional module; in each case the trivial idempotent has trace $2$ and is the code projector, and the nontrivial idempotents support the error subspaces.

What the Framework Adds and What It Does Not

What it does.

• It identifies the code space with the image of an idempotent $\tilde\Pi = |S|^{-1}\sum_{\tilde{g}\in S}\tilde{g}$ of the tensor-product algebra $\mathbb{M}_+^{\otimes n}$, where $S$ is a finite commutative group of involutions; the code projector is a Peirce component of a commutative subalgebra.
• It states the Knill–Laflamme condition as a condition on the sandwich $\tilde\Pi\tilde{E}_a^{*}\tilde{E}_b\tilde\Pi$, i.e. on the Gram matrix of the errors restricted to the code.
• It identifies the syndrome measurement with the projection onto the joint eigen-idempotents of the generators, a Peirce decomposition of the commutative subalgebra.
• It verifies idempotency, trace, Knill–Laflamme, and syndrome distinctness for the three-qubit bit-flip code and the five-qubit perfect code by explicit computation.

What it does not.

• It does not prove the sufficiency of the Knill–Laflamme condition in full generality; the argument is sketched and the standard proof is cited.
• It does not construct the recovery circuits for the codes; the recovery is characterized algebraically, and its circuit realization is a separate question treated with the gates and channels of the companion articles.
• It does not treat subsystem codes, topological codes, or continuous-variable codes; the article is confined to the finite Pauli stabilizer case.
• It does not predict anything beyond standard quantum error correction; the codes and thresholds are standard, and the framework transcribes them.

Open Questions

1. The stabilizer group and the biquaternion norm. The code is the image of an idempotent of $\mathbb{M}_+^{\otimes n}$. The biquaternion norm of a tensor product factors, $N(\tilde{g}\otimes\tilde{h}) = N(\tilde{g})N(\tilde{h})$, and the stabilizer elements are involutions with $N(\tilde{g}) = e_0$. Does the biquaternion norm give a criterion for the existence of codes, or a measure of the "distance" of a code, in the algebra?

2. Codes and the two sectors. The algebra splits into $\mathbb{M}_-$ and $\mathbb{M}_+$; error correction lives in $\mathbb{M}_+$. Is there an algebraic role for the material sector in the channel that produces the errors, given that the material sector is the classical one?

3. Commutative subalgebras and code classification. Stabilizer codes correspond to commutative subgroups of the Pauli group, and their classification is a problem in finite abelian groups. In the algebra, is there a classification of the commutative subalgebras of $\mathbb{B}^{\otimes n}$ that yields the code classification directly?

4. Fault tolerance. The threshold theorem requires that the error-correction machinery itself be protected. Does the algebraic formulation — with the recovery itself a channel on $\mathbb{M}_+^{\otimes n}$ — give a transparent form of the concatenation and its error propagation?

5. Empirical content. The codes and the stabilizer formalism are standard and experimentally realized; the framework reproduces them and adds no prediction.

Summary

Quantum error correction in the biquaternion framework is the theory of commutative subgroups of the Pauli involutions and their idempotents. A stabilizer group is an abelian subgroup $S$ of the Hermitian involutions of $\mathbb{M}_+^{\otimes n}$ with $-e_0^{\otimes n}\notin S$, generated by $n-k$ independent elements, and the code space is the image of the idempotent

$$ \tilde\Pi = \frac{1}{|S|}\sum_{\tilde{g}\in S}\tilde{g}, \qquad \tilde\Pi^2 = \tilde\Pi, \qquad \mathrm{Tr}(\tilde\Pi) = 2^k . $$

An error set $\{\tilde{E}_a\}$ is correctable if and only if the Knill–Laflamme condition

$$ \tilde\Pi\tilde{E}_a^{*}\tilde{E}_b\tilde\Pi = c_{ab}\tilde\Pi $$

holds for all $a,b$: the error operators, restricted to the code, have a scalar Gram matrix and cannot resolve the encoded state. The syndrome measurement is the joint measurement of the commuting generators, i.e. the projection onto the joint eigen-idempotents of a commutative subalgebra.

Two codes were constructed and verified. The three-qubit bit-flip code has $S$ generated by $Z_1Z_2$, $Z_2Z_3$, code projector $\tilde\Pi = \tfrac14(e_0^{\otimes3}+Z_1Z_2+Z_2Z_3+Z_1Z_3)$ with $\mathrm{Tr}(\tilde\Pi) = 2$, and satisfies $\tilde\PiX_iX_j\tilde\Pi = \delta_{ij}\tilde\Pi$, correcting any single bit flip and failing for phase flips. The five-qubit perfect code has the four cyclic generators $XZZXe_0$, $e_0XZZX$, $Xe_0XZZ$, $ZXe_0XZ$, code projector with $\mathrm{Tr}(\tilde\Pi) = 2$, and satisfies the Knill–Laflamme condition for all sixteen single-qubit Pauli errors; its fifteen nontrivial single-qubit errors have fifteen distinct nonzero syndromes, so it corrects an arbitrary single-qubit error and tiles the $32$-dimensional space exactly.

Summary of Notation

Further Reading

• P. W. Shor, "Scheme for reducing decoherence in quantum computer memory," Physical Review A 52 (1995) R2493–R2496, for the first quantum error-correcting code.
• A. M. Steane, "Error correcting codes in quantum theory," Physical Review Letters 77 (1996) 793–797, for the CSS construction.
• R. Laflamme, C. Miquel, J. P. Paz, and W. H. Zurek, "Perfect quantum error correcting code," Physical Review Letters 77 (1996) 198–201, for the five-qubit perfect code.
• C. H. Bennett, D. P. DiVincenzo, J. A. Smolin, and W. K. Wootters, "Mixed-state entanglement and quantum error correction," Physical Review A 54 (1996) 3824–3851, for the error-correction conditions and their entanglement interpretation.
• E. Knill and R. Laflamme, "Theory of quantum error-correcting codes," Physical Review A 55 (1997) 900–911, for the proof of the Knill–Laflamme condition.
• D. Gottesman, "Stabilizer codes and quantum error correction," Ph.D. thesis, Caltech (1997), for the stabilizer formalism and the code classification.
• D. A. Lidar and T. A. Brun (eds.), Quantum Error Correction (Cambridge, 2013), for the modern development of the formalism.
• The companion articles of this series: Quantum Channels and the Reversible/Irreversible Dichotomy, Quantum Gates and Circuits in Biquaternionic Form, Decoherence as Idempotent Projection, and The Bell Basis as the Idempotent Basis of $\mathbb{B}\otimes\mathbb{B}$.