Stabilizer code

In quantum computing and quantum communication, a stabilizer code is a class of quantum codes for performing quantum error correction. The toric code, and surface codes more generally, are types of stabilizer codes considered very important for the practical realization of quantum information processing. In fact, the toric code and surface codes also belong to a special class of stabilizer codes, CSS codes. An example of a stabilizer code that is not a CSS code is the five-qubit error correcting code. Stabilizer codes are strikingly similar to classical linear block codes in their operation and performance. Just as a classical linear block code can be defined by its parity-check matrix, a quantum stabilizer code also has a "parity check" structure defined by its stabilizers. However, stabilizers for a -qubit code are -qubit Pauli operators instead of classical -bit strings, and they must all commute with each other for the code to be valid. The theory of stabilizer codes allows one to import some classical binary or quaternary codes for use as a quantum code. However, when importing the classical code, it must satisfy the dual-containing (or self-orthogonality) constraint. Researchers have found many examples of classical codes satisfying this constraint, but most classical codes do not. Nevertheless, it is still useful to import classical codes in this way.…

In quantum computing and quantum communication, a stabilizer code is a class of quantum codes for performing quantum error correction. The toric code, and surface codes more generally, are types of stabilizer codes considered very important for the practical realization of quantum information processing. In fact, the toric code and surface codes also belong to a special class of stabilizer codes, CSS codes. An example of a stabilizer code that is not a CSS code is the five-qubit error correcting code. Stabilizer codes are strikingly similar to classical linear block codes in their operation and performance. Just as a classical linear block code can be defined by its parity-check matrix, a quantum stabilizer code also has a "parity check" structure defined by its stabilizers. However, stabilizers for a -qubit code are -qubit Pauli operators instead of classical -bit strings, and they must all commute with each other for the code to be valid. The theory of stabilizer codes allows one to import some classical binary or quaternary codes for use as a quantum code. However, when importing the classical code, it must satisfy the dual-containing (or self-orthogonality) constraint. Researchers have found many examples of classical codes satisfying this constraint, but most classical codes do not. Nevertheless, it is still useful to import classical codes in this way. The entanglement-assisted stabilizer formalism can also overcome this difficulty. Algebraic-geometry codes provide another source of stabilizer constructions. Matsumoto used algebraic curves to obtain asymptotically good binary stabilizer codes and to improve the Ashikhmin-Litsyn-Tsfasman bound for quantum codes. \mathcal{S} = \left\langle g_{1},\ldots,g_{n-k}\right\rangle. The generators must be independent in the sense that none of them are a product of any number of other generators, or the negation thereof (otherwise they would generate -I^{\otimes n} ). They are analogous to the rows of the parity-check matrix of a classical linear block code. ==Examples== ===Classical repetition code=== As a simple example, the 3-bit classical repetition code can be regarded as a quantum stabilizer code. It encodes logical qubit into physical qubits, and protects against a single bit-flip error (represented as a Pauli operator in a quantum information context). However, since it does not protect against single-qubit phase-flip errors , its code distance as a quantum code is . The stabilizer group of the 3-qubit repetition code has generators: \begin{array} [c]{ccc} g_{1} & = & Z & Z & I\\ g_{2} & = & I & Z & Z\\ \end{array} The stabilizer indicates that, if the first and second qubits in a valid code state are both measured in the basis, the results will always be the same (i.e., the product of eigenvalues will always be ). Similarly, indicates that the basis measurement on the second and third qubits always yield the same result. Unsurprisingly, the codespace of this code is \text{Span}(|000\rangle, |111\rangle) . Usually, the physical state |000\rangle and |111\rangle are identified with the |0\rangle and |1\rangle states of the logical qubit respectively (often written as |\overline{0}\rangle and |\overline{1}\rangle to distinguish them from physical states). As a quantum code, the codespace also includes superpositions of |\overline{0}\rangle and |\overline{1}\rangle , such as |\overline{+}\rangle = |000\rangle + |111\rangle and |\overline{-}\rangle = |000\rangle - |111\rangle . Note that a phase-flip error on any one physical qubit will change |\overline{+}\rangle to |\overline{-}\rangle , and vice versa. ===Five-qubit code=== An example of a stabilizer code is the five qubit stabilizer code. It encodes logical qubit into physical qubits. Its stabilizer group has generators: \begin{array} [c]{ccccccc} g_{1} & = & X & Z & Z & X & I\\ g_{2} & = & I & X & Z & Z & X\\ g_{3} & = & X & I & X & Z & Z\\ g_{4} & = & Z & X & I & X & Z \end{array} As we will show later, this code protects against an arbitrary single-qubit error, and thus it has code distance . By definition, a logical operator must map a valid code state |\psi\rangle into a valid code state . This means that for each stabilizer , SP|\psi\rangle = P|\psi\rangle = PS|\psi\rangle (the second equality holds since |\psi\rangle is itself a valid code state), which is always true when and commute and never true when they anti-commute. Therefore the set of valid logical operators in is , the centralizer of \mathcal{S} (i.e., the subgroup of elements that commute with all members of , also known as the commutant). However, not all these logical operators act non-trivially on the logical qubit. In particular, since \mathcal{S} is an abelian subgroup, \mathcal{S} is also contained in . In fact, when , , meaning that implements the logical identity operator I^{\otimes k} . Furthermore, for any other logical operator , acts identically to on the code state, and thus they implement the same logical operator. Factoring out this equivalence gives the quotient group , which is isomorphic to . Therefore all -qubit logical Pauli operators can be chosen to be -qubit physical Pauli operators. To explicitly specify the logical qubit decomposition, one usually chooses logical operators . Each of these operators or is a representative for the equivalence class \overline{Z_i}\mathcal{S} or \overline{X_i}\mathcal{S} implementing the same logical operator. These operators need to satisfy the following conditions: are all independent: The product of any nonempty subset of these operators cannot be a scalar multiple of I^{\otimes n} . Among , the only pairs that anti-commute are and for the same . Other pairs — two logical operators on different logical qubits, one logical operator and one stabilizer generator, or two stabilizer generators — all commute. g_{1} & = & Z & Z & I\\ g_{2} & = & I & Z & Z\\ \overline{Z} & = & Z & I & I\\ \overline{X} & = & X & X & X \end{array} Other single-qubit operators are alternative implementations of the logical operator: , . This is consistent with the above observation that any single-qubit phase-flip error changes |\overline{+}\rangle to |\overline{-}\rangle , and vice versa. It is also straightforward to check that applying , i.e., bit-flipping all three qubits, changes |\overline{0}\rangle to |\overline{1}\rangle , and vice versa. For the five-qubit code, the logical operator representatives are usually chosen as: \begin{array} [c]{ccccccc} g_{1} & = & X & Z & Z & X & I\\ g_{2} & = & I & X & Z & Z & X\\ g_{3} & = & X & I & X & Z & Z\\ g_{4} & = & Z & X & I & X & Z\\ \overline{Z} & = & Z & Z & Z & Z & Z\\ \overline{X} & = & X & X & X & X & X \end{array} Note, however, that these are not the logical operator representative candidates with the lowest weight (number of non- Pauli factors). For example, has weight 3. Because \mathcal{E} and \mathcal{S} are both subsets of \Pi^{n} , an error E\in\mathcal{E} either commutes or anti-commutes with any particular element S \in \mathcal{S} . If anti-commutes with an element , then SE|\psi\rangle = -ES|\psi\rangle = -E|\psi\rangle which means that E|\psi\rangle is in the -eigenspace of rather than the -eigenspace, and thus is detectable by measuring . Actually it suffices to measure each stabilizer generator , since if commutes with every , then will also commute with the product of any number of them. In this case E \in C(\mathcal{S}) is a logical operator and thus cannot be detected by the code. However, E \in \mathcal{S} is again a special case, where implements the logical identity operator: Even though it is not detectable, it also does not corrupt the encoded state. This also holds for any scalar multiple of E \in \mathcal{S} , since a global phase has no physical effect. We define an undetectable logical error as one that is undetectable but does corrupt the encoded state, i.e., E \in C(\mathcal{S}) \setminus \{+1, +i, -1, -i\} \otimes \mathcal{S} = C(\mathcal{S}) \setminus C(C(\mathcal{S})). The equality above gives an alternative characterization of an undetectable logical error : must commute with all stabilizers, but not with all logical operators. This characterization is often more convenient since one only need to check commutativity with the generators , instead of solving a system of linear equations to determine if is the product of some subset of up to global phase. Operationally, each stabilizer generator can be measured via a parity measurement without disturbing states in the codespace. The combination of results of measuring each is known as the syndrome \mathbf{r} , represented as a binary vector \mathbf{r} with length n-k whose elements indicate whether the error commutes or anti-commutes with each stabilizer generator . The 3-qubit repetition code can correct single-qubit bit-flip errors, which means that it satisfies the error-correction conditions for \mathcal{E} = \{I, X_1, X_2, X_3\} . Indeed, the only undetectable logical error that consists only of and is with weight 3, and the product of two errors in \mathcal{E} . This can also be verified by explicitly checking the corrections corresponding to each syndrome: The five-qubit code can correct any single-qubit error, i.e., it satisfies the error-correction conditions for \mathcal{E} = \{I, X_i, Y_i, Z_i\} ( distinct errors). This can be verified either by showing that all undetectable logical errors of this code has weight at least 3, or by explicitly checking the syndromes. For the five-qubit code again each syndrome corresponds to one error in \mathcal{E} , although this is not typical for stabilizer codes: For codes like the surface code with high code distances and relatively low-weight stabilizers, one syndrome will usually correspond to many correctable errors that differ from each other by stabilizers. ==References== D. Gottesman, "Stabilizer codes and quantum error correction," quant-ph/9705052, Caltech Ph.D. thesis. https://arxiv.org/abs/quant-ph/9705052 A. Calderbank, E. Rains, P. Shor, and N. Sloane, “Quantum error correction via codes over GF(4),” IEEE Trans. Inf. Theory, vol. 44, pp. 1369–1387, 1998. Available at https://arxiv.org/abs/quant-ph/9608006

Text derived from https://en.wikipedia.org/w/index.php?oldid=1349886574 under CC BY-SA 4.0; modifications have been made.