Quantum error correction

Quantum error correction (QEC) is used in quantum computing to protect quantum information from errors due to decoherence and other quantum noise. Quantum error correction is theorised as essential to achieve fault tolerant quantum computing that can reduce the effects of noise on stored quantum information, faulty quantum gates, faulty quantum preparation, and faulty measurements. This would allow algorithms of greater circuit depth.^[1]

Classical error correction employs redundancy. The simplest albeit inefficient approach is the repetition code. The idea is to store the information multiple times, and—if these copies are later found to disagree—take a majority vote; e.g. suppose we copy a bit in the one state three times. Suppose further that a noisy error corrupts the three-bit state so that one of the copied bits is equal to zero but the other two are equal to one. Assuming that noisy errors are independent and occur with some sufficiently low probability p, it is most likely that the error is a single-bit error and the transmitted message is three ones. It is possible that a double-bit error occurs and the transmitted message is equal to three zeros, but this outcome is less likely than the above outcome. In this example, the logical information was a single bit in the one state, the physical information are the three copied bits, and determining what logical state is encoded in the physical state is called decoding. Similar to classical error correction, QEC codes do not always correctly decode logical qubits, but their use reduces the effect of noise.

Copying quantum information is not possible due to the no-cloning theorem. This theorem seems to present an obstacle to formulating a theory of quantum error correction. But it is possible to spread the (logical) information of one qubit onto a highly entangled state of several (physical) qubits. Peter Shor first discovered this method of formulating a quantum error correcting code by storing the information of one qubit onto a highly entangled state of nine qubits.

Classical error correcting codes use a syndrome measurement to diagnose which error corrupts an encoded state. An error can then be reversed by applying a corrective operation based on the syndrome. Quantum error correction also employs syndrome measurements. It performs a multi-qubit measurement that does not disturb the quantum information in the encoded state but retrieves information about the error. Depending on the QEC code used, syndrome measurement can determine the occurrence, location and type of errors. In most QEC codes, the type of error is either a bit flip, or a sign (of the phase) flip, or both (corresponding to the Pauli matrices X, Z, and Y). The measurement of the syndrome has the projective effect of a quantum measurement, so even if the error due to the noise was arbitrary, it can be expressed as a combination of basis operations called the error basis (which is given by the Pauli matrices and the identity). To correct the error, the Pauli operator corresponding to the type of error is used on the corrupted qubit to revert the effect of the error.

The syndrome measurement provides information about the error that has happened, but not about the information that is stored in the logical qubit—as otherwise the measurement would destroy any quantum superposition of this logical qubit with other qubits in the quantum computer, which would prevent it from being used to convey quantum information.

Bit flip code[edit]

The repetition code works in a classical channel, because classical bits are easy to measure and to repeat. This approach does not work for a quantum channel in which, due to the no-cloning theorem, it is not possible to repeat a single qubit three times. To overcome this, a different method has to be used, such as the three-qubit bit flip code first proposed by Asher Peres in 1985.^[2] This technique uses entanglement and syndrome measurements and is comparable in performance with the repetition code.

Consider the situation in which we want to transmit the state of a single qubit through a noisy channel . Let us moreover assume that this channel either flips the state of the qubit, with probability , or leaves it unchanged. The action of on a general input can therefore be written as .

Let be the quantum state to be transmitted. With no error correcting protocol in place, the transmitted state will be correctly transmitted with probability . We can however improve on this number by encoding the state into a greater number of qubits, in such a way that errors in the corresponding logical qubits can be detected and corrected. In the case of the simple three-qubit repetition code, the encoding consists in the mappings and . The input state is encoded into the state . This mapping can be realized for example using two CNOT gates, entangling the system with two ancillary qubits initialized in the state .^[3] The encoded state is what is now passed through the noisy channel.

The channel acts on by flipping some subset (possibly empty) of its qubits. No qubit is flipped with probability , a single qubit is flipped with probability , two qubits are flipped with probability , and all three qubits are flipped with probability . Note that a further assumption about the channel is made here: we assume that acts equally and independently on each of the three qubits in which the state is now encoded. The problem is now how to detect and correct such errors, while not corrupting the transmitted state.

Let us assume for simplicity that is small enough that the probability of more than a single qubit being flipped is negligible. One can then detect whether a qubit was flipped, without also querying for the values being transmitted, by asking whether one of the qubits differs from the others. This amounts to performing a measurement with four different outcomes, corresponding to the following four projective measurements:

This reveals which qubits are different from the others, without at the same time giving information about the state of the qubits themselves. If the outcome corresponding to is obtained, no correction is applied, while if the outcome corresponding to is observed, then the Pauli X gate is applied to the -th qubit. Formally, this correcting procedure corresponds to the application of the following map to the output of the channel:

Note that, while this procedure perfectly corrects the output when zero or one flips are introduced by the channel, if more than one qubit is flipped then the output is not properly corrected. For example, if the first and second qubits are flipped, then the syndrome measurement gives the outcome , and the third qubit is flipped, instead of the first two. To assess the performance of this error correcting scheme for a general input we can study the fidelity between the input and the output . Being the output state correct when no more than one qubit is flipped, which happens with probability , we can write it as , where the dots denote components of resulting from errors not properly corrected by the protocol. It follows that

This fidelity is to be compared with the corresponding fidelity obtained when no error correcting protocol is used, which was shown before to equal . A little algebra then shows that the fidelity after error correction is greater than the one without for . Note that this is consistent with the working assumption that was made while deriving the protocol (of being small enough).

Sign flip code[edit]

Flipped bits are the only kind of error in classical computer, but there is another possibility of an error with quantum computers, the sign flip. Through the transmission in a channel the relative sign between and can become inverted. For instance, a qubit in the state may have its sign flip to

The original state of the qubit

will be changed into the state

In the Hadamard basis, bit flips become sign flips and sign flips become bit flips. Let be a quantum channel that can cause at most one phase flip. Then the bit flip code from above can recover by transforming into the Hadamard basis before and after transmission through .

Shor code[edit]

The error channel may induce either a bit flip, a sign flip (i.e., a phase flip), or both. It is possible to correct for both types of errors on any one qubit using a QEC code, which can be done using the Shor code published in 1995.^[4][5]: 10 This is equivalent to saying the Shor code corrects arbitrary single-qubit errors.

Let be a quantum channel that can arbitrarily corrupt a single qubit. The 1st, 4th and 7th qubits are for the sign flip code, while the three groups of qubits (1,2,3), (4,5,6), and (7,8,9) are designed for the bit flip code. With the Shor code, a qubit state will be transformed into the product of 9 qubits , where

If a bit flip error happens to a qubit, the syndrome analysis will be performed on each block of qubits (1,2,3), (4,5,6), and (7,8,9) to detect and correct at most one bit flip error in each block.

If the three bit flip group (1,2,3), (4,5,6), and (7,8,9) are considered as three inputs, then the Shor code circuit can be reduced as a sign flip code. This means that the Shor code can also repair a sign flip error for a single qubit.

The Shor code also can correct for any arbitrary errors (both bit flip and sign flip) to a single qubit. If an error is modeled by a unitary transform U, which will act on a qubit , then can be described in the form

where ,,, and are complex constants, I is the identity, and the Pauli matrices are given by

If U is equal to I, then no error occurs. If , a bit flip error occurs. If , a sign flip error occurs. If then both a bit flip error and a sign flip error occur. In other words, the Shor code can correct any combination of bit or phase errors on a single qubit.

Bosonic codes[edit]

Several proposals have been made for storing error-correctable quantum information in bosonic modes.^{[clarification needed]} Unlike a two-level system, a quantum harmonic oscillator has infinitely many energy levels in a single physical system. Codes for these systems include cat,^[6][7][8] Gottesman-Kitaev-Preskill (GKP),^[9] and binomial codes.^[10][11] One insight offered by these codes is to take advantage of the redundancy within a single system, rather than to duplicate many two-level qubits.

Written in the Fock basis, the simplest binomial encoding is

where the subscript L indicates a «logically encoded» state. Then if the dominant error mechanism of the system is the stochastic application of the bosonic lowering operator the corresponding error states are and respectively. Since the codewords involve only even photon number, and the error states involve only odd photon number, errors can be detected by measuring the photon number parity of the system.^[10][12] Measuring the odd parity will allow correction by application of an appropriate unitary operation without knowledge of the specific logical state of the qubit. However, the particular binomial code above is not robust to two-photon loss.

General codes[edit]

In general, a quantum code for a quantum channel is a subspace , where is the state Hilbert space, such that there exists another quantum channel with

where is the orthogonal projection onto . Here is known as the correction operation.

A non-degenerate code is one for which different elements of the set of correctable errors produce linearly independent results when applied to elements of the code. If distinct of the set of correctable errors produce orthogonal results, the code is considered pure.^[13]

Models[edit]

Over time, researchers have come up with several codes:

• Peter Shor’s 9-qubit-code, a.k.a. the Shor code, encodes 1 logical qubit in 9 physical qubits and can correct for arbitrary errors in a single qubit.
• Andrew Steane found a code that does the same with 7 instead of 9 qubits, see Steane code.
• Raymond Laflamme and collaborators found a class of 5-qubit codes that do the same, which also have the property of being fault-tolerant. A 5-qubit code is the smallest possible code that protects a single logical qubit against single-qubit errors.
• A generalisation of the technique used by Steane, to develop the 7-qubit code from the classical [7, 4] Hamming code, led to the construction of an important class of codes called the CSS codes, named for their inventors: Robert Calderbank, Peter Shor and Andrew Steane. According to the quantum Hamming bound, encoding a single logical qubit and providing for arbitrary error correction in a single qubit requires a minimum of 5 physical qubits.
• A more general class of codes (encompassing the former) are the stabilizer codes discovered by Daniel Gottesman, and by Robert Calderbank, Eric Rains, Peter Shor, and N. J. A. Sloane; these are also called additive codes.
• Two dimensional Bacon–Shor codes are a family of codes parameterized by integers m and n. There are nm qubits arranged in a square lattice.^[14]
• A newer idea is Alexei Kitaev’s topological quantum codes and the more general idea of a topological quantum computer.
• Todd Brun, Igor Devetak, and Min-Hsiu Hsieh also constructed the entanglement-assisted stabilizer formalism as an extension of the standard stabilizer formalism that incorporates quantum entanglement shared between a sender and a receiver.

That these codes allow indeed for quantum computations of arbitrary length is the content of the quantum threshold theorem, found by Michael Ben-Or and Dorit Aharonov, which asserts that you can correct for all errors if you concatenate quantum codes such as the CSS codes—i.e. re-encode each logical qubit by the same code again, and so on, on logarithmically many levels—provided that the error rate of individual quantum gates is below a certain threshold; as otherwise, the attempts to measure the syndrome and correct the errors would introduce more new errors than they correct for.

As of late 2004, estimates for this threshold indicate that it could be as high as 1–3%,^[15] provided that there are sufficiently many qubits available.

Experimental realization[edit]

There have been several experimental realizations of CSS-based codes. The first demonstration was with nuclear magnetic resonance qubits.^[16] Subsequently, demonstrations have been made with linear optics,^[17] trapped ions,^[18][19] and superconducting (transmon) qubits.^[20]

In 2016 for the first time the lifetime of a quantum bit was prolonged by employing a QEC code.^[21] The error-correction demonstration was performed on Schrodinger-cat states encoded in a superconducting resonator, and employed a quantum controller capable of performing real-time feedback operations including read-out of the quantum information, its analysis, and the correction of its detected errors. The work demonstrated how the quantum-error-corrected system reaches the break-even point at which the lifetime of a logical qubit exceeds the lifetime of the underlying constituents of the system (the physical qubits).

Other error correcting codes have also been implemented, such as one aimed at correcting for photon loss, the dominant error source in photonic qubit schemes.^[22][23]

In 2021, an entangling gate between two logical qubits encoded in topological quantum error-correction codes has first been realized using 10 ions in a trapped-ion quantum computer.^[24][25] 2021 also saw the first experimental demonstration of fault-tolerant Bacon-Shor code in a single logical qubit of a trapped-ion system, i.e. a demonstration for which the addition of error correction is able to suppress more errors than is introduced by the overhead required to implement the error correction^[26][27] as well as fault tolerant Steane code.^[28][29]

In 2022, researchers at the University of Innsbruck have demonstrated a fault-tolerant universal set of gates on two logical qubits in a trapped-ion quantum computer. They have performed a logical two-qubit controlled-NOT gate between two instances of the seven-qubit colour code, and fault-tolerantly prepared a logical magic state.^[30]

Quantum error-correction without encoding and parity-checks[edit]

Also in 2022, a research^[31] at University of Engineering and Technology Lahore demonstrated error-cancellation by inserting single-qubit Z-axis rotation gates into strategically chosen locations of the superconductor quantum circuits. The scheme has been shown to effectively correct errors that would otherwise rapidly add up under constructive interference of coherent noise. This is a circuit-level calibration scheme^[32] that traces deviations (e.g. sharp dips or notches) in the decoherence curve to detect and localize the coherent error, but does not require encoding or parity measurements. However, further investigation is needed to establish the effectiveness of this method for the incoherent noise.^[31]

See also[edit]

• Error detection and correction
• Soft error

References[edit]

Further reading[edit]

• Daniel Lidar and Todd Brun, ed. (2013). Quantum Error Correction. Cambridge University Press.
• La Guardia, Giuliano Gadioli, ed. (2020). Quantum Error Correction: Symmetric, Asymmetric, Synchronizable, and Convolutional Codes. Springer Nature.
• Frank Gaitan (2008). Quantum Error Correction and Fault Tolerant Quantum Computing. Taylor & Francis.

• Freedman, Michael H.; Meyer, David A.; Luo, Feng: Z₂-Systolic freedom and quantum codes. Mathematics of quantum computation, 287–320, Comput. Math. Ser., Chapman & Hall/CRC, Boca Raton, FL, 2002.
• Freedman, Michael H.; Meyer, David A. (1998). «Projective plane and planar quantum codes». Found. Comput. Math. 2001 (3): 325–332. arXiv:quant-ph/9810055. Bibcode:1998quant.ph.10055F.
• Lassen, Mikael; Sabuncu, Metin; Huck, Alexander; Niset, Julien; Leuchs, Gerd; Cerf, Nicolas J.; Andersen, Ulrik L. (2010). «Quantum optical coherence can survive photon losses using a continuous-variable quantum erasure-correcting code». Nature Photonics. 4 (1): 10. Bibcode:2010NaPho…4…10W. doi:10.1038/nphoton.2009.243.

External links[edit]

• Knill, E. (2004). «Quantum Computing with Very Noisy Devices». Nature. 434 (7029): 39–44. arXiv:quant-ph/0410199. Bibcode:2005Natur.434…39K. doi:10.1038/nature03350. PMID 15744292. S2CID 4420858.
• Error-check breakthrough in quantum computing^{[permanent dead link]}
• «Topological Quantum Error Correction». Quantum Light. University of Sheffield. September 28, 2018. Archived from the original on 2021-12-22 – via YouTube.

== Quantum Error Correction ==

Building a quantum computer or a quantum communications device in the real world means having to deal with errors. Any qubit stored unprotected or one transmitted through a communications channel will inevitably come out at least slightly changed. The theory of quantum error-correcting codes has been developed to counteract noise introduced in this way. By adding extra qubits and carefully encoding the quantum state we wish to protect, a quantum system can be insulated to great extent against errors.

To build a quantum computer, we face an even more daunting task: If our quantum gates are imperfect, everything we do will add to the error. The theory of fault-tolerant quantum computation tells us how to perform operations on states encoded in a quantum error-correcting code without compromising the code’s ability to protect against errors.

In general, a quantum error-correcting code is a subspace of a Hilbert space designed so that any of a set of possible errors can be corrected by an appropriate quantum operation. Specifically:

Definition 1 Let H_n be a 2ⁿ-dimensional Hilbert space (n qubits), and let C be a K-dimensional subspace of H_n. Then C is an ((n,K)) (binary) quantum error-correcting code (QECC) correcting the set of errors E = {E_a} iff ∃R s.t. R is a quantum operation and (R ∘ E_a)(∣ψ⟩) = ∣ψ⟩ for all E_a ∈ E, ∣ψ⟩ ∈ C.

R is called the recovery or decoding operation and serves to actually perform the correction of the state. The decoder is sometimes also taken to map H_n into an unencoded Hilbert space H_logK isomorphic to C. Thus should be distinguished from the encoding operation which maps H_logK into H_n, determining the imbedding of C. The computational complexity of the encoder is frequently a great deal lower than that of the decoder. In particular, the task of determining what error has occured can be computationally difficult (NP-hard, in fact), and designing codes with efficient decoding algorithms is an important task in quantum correction as in classical error correction.

This article will cover only binary quantum codes, built with qubits as registers, but all of the techniques discussed here can be generalized to higher-dimensional registers, or qudits.

To determine whether a given subspace is able to correct a given set of errors, we can apply the quantum error-correction conditions:

Theorem 1 A QECC C corrects the set of errors E iff

⟨ψ_i∣E_a^†E_b∣ψ_j⟩ = C_abδ_ij

where E_a, A_b ∈ E and {∣ψ_i⟩} form an orthonormal basis for C. 

The salient point in these error-correction conditions is that the matrix element C_ab does not depend on the encoded basis states i and j, which roughly speaking indicates that neither the environment nor the decoding operation learns any information about the encoded state. We can imagine the various possible errors taking the subspace C into other subspaces of H_n, and we want those subspaces to be isomorphic to C, and to be distinguishable from each other by an appropriate measurement. For instance, if C_ab = δ_ab, then the various erroneous subspaces are orthogonal to each other.

Because of the linearity of quantum mechanics, we can always take the set of errors E to be a linear space: If a QECC corrects E_a and E_b, it will also correct αE_a + βE_b using the same recovery operation. In addition, if we write any superoperator S in terms of its operator-sum representation S(ρ) ↦ ∑A_kρA_k^†, a QECC that corrects the set of errors {A_k} automatically corrects S as well. Thus, it is sufficient in general to check that the error-correction conditions hold for a basis of errors.

Frequently, we are interested in codes that correct any error affecting t or fewer physical qubits. In that case, let us consider tensor products of the Pauli matrices

$I=begin{pmatrix}1&0\0&1end{pmatrix}, X=begin{pmatrix}0&1\1&0end{pmatrix}, Y=begin{pmatrix}0&-i\i&0end{pmatrix}, Z=begin{pmatrix}1&0\0&-1end{pmatrix}$

Define the Pauli group P_n as the group consisting of tensor products of I, X, Y, and Z on n qubits, with an overall phase of  ± 1 or  ± i. The weight wt(P) of a Pauli operator P ∈ P_n is the number of qubits on which it acts as X, Y, or Z (i.e., not as the identity). Then the Pauli operators of weight t or less form a basis for the set of all errors acting on t or fewer qubits, so a QECC which corrects these Pauli operators corrects all errors acting on up to t qubits. If we have a channel which causes errors independently with probability O(ε) on each qubit in the QECC, then the code will allow us to decode a correct state except with probability O(ε^t + 1), which is the probability of having more than t errors. We get a similar result in the case where the noise is a general quantum operation on each qubit which differs from the identity by something of size O(ε).

Definition 2 The distance d of an ((n, K)) is the smallest weight of a nontrivial Pauli operator E ∈ P_n s.t. the equation

⟨ψ_i∣E∣ψ_j⟩ = C(E)δ_ij 

fails.

We use the notation ((n, K, d)) to refer to an ((n, K)) QECC with distance d. Note that for P, Q ∈ P_n, wt(PQ) ≤ wt(P) + wt(Q). Then by comparing the definition of distance with the quantum error-correction conditions, we immediately see that a QECC corrects t general errors iff its distance $d > 2t$. If we are instead interested in erasure errors, when the location of the error is known but not its precise nature, a distance d code corrects d − 1 erasure errors. If we only wish to detect errors, a distance d code can detect errors on up to d − 1 qubits.

One of the central problems in the theory of quantum error correction is to find codes which maximize the ratios (logK)/n and d/n, so they can encode as many qubits as possible and correct as many errors as possible. Conversely, we are also interested in the problem of setting upper bounds on achievable values of (logK)/n and d/n. The quantum Singleton bound (or Knill-Laflamme bound) states that any ((n, K, d)) QECC must satisfy

n − logK ≥ 2d − 2

We can set a lower bound on the existence of QECCs using the quantum Gilbert-Varshamov bound, which states that, for large n, an ((n, 2^k, d)) QECC exists provided that

k/n ≤ 1 − (d/n)log3 − h(d/n), 

where h(x) =  − xlogx − (1 − x)log(1 − x) is the binary Hamming entropy. Note that the Gilbert-Varshamov bound simply states that codes at least this good exist; it does not suggest that better codes cannot exist.

Stabilizer Codes

In order to better manipulate and discover quantum error-correcting codes, it is helpful to have a more detailed mathematical structure to work with. The most widely-used structure gives a class of codes known as stabilizer codes. They are less general than arbitrary quantum codes, but have a number of useful properties that make them easier to work with than the general QECC.

Definition 3 Let S ⊂ P_n be an Abelian subgroup of the Pauli group that does not contain  − 1 or  ± i, and let C(S) = {∣ψ⟩ s.t. P∣ψ⟩ = ∣ψ⟩∀P ∈ S. Then C(S) is a stabilizer code and S is its stabilizer.

Because of the simple structure of the Pauli group, any Abelian subgroup has order 2^n − k for some k and can easily be specified by giving a set of n − k commuting generators.

The codewords of the QECC are by definition in the  + 1-eigenspace of all elements of the stabilizer, but an error E acting on a codeword will move the state into the  − 1-eigenspace of any stabilizer element M which anticommutes with E:

M(E∣ψ⟩) =  − EM∣ψ⟩ =  − E∣ψ⟩.

Thus, measuring the eigenvalues of the generators of S tells us information about the error that has occurred. The set of such eigenvalues can be represented as an (n − k)-dimensional binary vector known as the error syndrome. Note that the error syndrome does not tell us anything about the encoded state, only about the error that has occurred.

Theorem 2 Let S be a stabilizer with n − k generators, and let S^⊥ = {E ∈ P_n s.t. [E, M] = 0 ∀M ∈ S}. Then S encodes k qubits and has distance d, where d is the smallest weight of an operator in S^⊥  S.

We use the notation $<a href=»/search/node/n%2Ck%2Cd» title=»Search this site for content like “n,k,d”.» class=»freelink freelink-search notfound freelink-internal»>n,k,d</a>$ to a refer to such a stabilizer code. Note that the square brackets specify that the code is a stabilizer code, and that the middle term k refers to the number of encoded qubits, and not the dimension 2^k of the encoded subspace, as for the general QECC (whose dimension might not be a power of 2).

S^⊥ is the set of Pauli operators that commute with all elements of the stabilizer. They would therefore appear to be those errors which cannot be detected by the code. However, the theorem specifies the distance of the code by considering S^⊥  S. A Pauli operator P ∈ S cannot be detected by the code, but there is in fact no need to detect it, since all codewords remain fixed under P, making it equivalent to the identity operation. A distance d stabilizer code which has nontrivial P ∈ S with $wt(P) &lt; d$ is called degenerate, whereas one which does not is non-degenerate. The phenomenon of degeneracy has no analogue for classical error correcting codes, and makes the study of quantum codes substantially more difficult than the study of classical error correction. For instance, a standard bound on classical error correction is the Hamming bound (or sphere-packing bound), but the analogous quantum Hamming bound

k/n ≤ 1 − (t/n)log3 − h(t/n)

for $<a href=»/search/node/n%2Ck%2C2t%2B1″ title=»Search this site for content like “n,k,2t+1”.» class=»freelink freelink-search notfound freelink-internal»>n,k,2t+1</a>$ codes (when n is large) is only known to apply to non-degenerate quantum codes (though in fact we do not know of any degenerate QECCs that violate the quantum Hamming bound).

An example of a stabilizer code is the 5-qubit code, a $<a href=»/search/node/5%2C1%2C3″ title=»Search this site for content like “5,1,3”.» class=»freelink freelink-search notfound freelink-internal»>5,1,3</a>$ code whose stabilizer can be generated by

$begin{matrix}
X otimes Z otimes Z otimes X otimes I, \
I otimes X otimes Z otimes Z otimes X, \
X otimes I otimes X otimes Z otimes Z, \
Z otimes X otimes I otimes X otimes Z. end{matrix}$

The 5-qubit code is a non-degenerate code, and is the smallest possible QECC which corrects 1 error (as one can see from the quantum Singleton bound).

It is frequently useful to consider other representations of stabilizer codes. For instance, P ∈ P_n can be represented by a pair of n-bit binary vectors (p_X∣p_Z) where p_X is 1 for any location where P has an X or Y tensor factor and is 0 elsewhere, and p_Z is 1 for any location where P has a Y or Z tensor factor. Two Pauli operators P = (p_X∣p_Z) and Q = (q_X∣q_Z) commute iff p_X ⋅ q_Z + p_Z ⋅ q_X = 0. Then the stabilizer for a code becomes a pair of (n − k) × n binary matrices, and most interesting properties can be determined by an appropriate linear algebra exercise. Another useful representation is to map the single-qubit Pauli operators I, X, Y, Z to the finite field GF(4), which sets up a connection between stabilizer codes and a subset of classical codes on 4-dimensional registers.

Using the stabilizer formalism limits the available states but there is still a lot of interesting freedom. For N qubits, there are 2^Nπ_i = 1^N(2ⁱ + 1) stabilizer states[Gottesmann and Aaronson PRA 2004], as opposed to the infinite number of general states. So, for example, there are only 6 stabilizer states on one qubit. However for larger N an exponentially growing number of states are possible. These include EPR and GHZ states. Despite being efficiently simulable, most stabilizer states on a large number of qubits exhibit maximal bipartite entanglement[Dahlsten and Plenio, QIC 2006].

CSS Codes

CSS codes are a very useful class of stabilizer codes invented by Calderbank and Shor, and by Steane. The construction takes two binary classical linear codes and produces a quantum code, and can therefore take advantage of much existing knowledge from classical coding theory. In addition, CSS codes have some very useful properties which make them excellent choices for fault-tolerant quantum computation.

A classical [n, k, d] linear code (n physical bits, k logical bits, classical distance d) can be defined in terms of an (n − k) × n binary parity check matrix H — every classical codeword v must satisfy Hv = 0. Each row of the parity check matrix can be converted into a Pauli operator by replacing each 0 with an I operator and each 1 with a Z operator. Then the stabilizer code generated by these operators is precisely a quantum version of the classical error-correcting code given by H. If the classical distance d = 2t + 1, the quantum code can correct t bit flip (X) errors, just as could the classical code.

If we want to make a QECC that can also correct phase (Z) errors, we should choose two classical codes C₁ and C₂, with parity check matrices H₁ and H₂. Let C₁ be an [n, k₁, d₁] code and let C₂ be an [n, k₂, d₂] code. We convert H₁ into stabilizer generators as above, replacing each 0 with I and each 1 with Z. For H₂, we perform the same procedure, but each 1 is instead replaced by X. The code will be able to correct bit flip (X) errors as if it had a distance d₁ and to correct phase (Z) errors as if it had a distance d₂. Since these two operations are completely separate, it can also correct Y errors as both a bit flip and a phase error. Thus, the distance of the quantum code is at least min(d₁, d₂), but might be higher because of the possibility of degeneracy.

However, in order to have a stabilizer code at all, the generators produced by the above procedure must commute. Define the dual C^⊥ of a classical code C as the set of vectors w s.t. w ⋅ v = 0 for all v ∈ C. Then the Z generators from H₁ will all commute with the X generators from H₂ iff C₂^⊥ ⊆ C₁ (or equivalently, C₁^⊥ ⊆ C₂). When this is true, C₁ and C₂ define an $<a href=»/search/node/n%2Ck_1%2Bk_2-n%2Cd» title=»Search this site for content like “n,k_1+k_2-n,d”.» class=»freelink freelink-search notfound freelink-internal»>n,k_1+k_2-n,d</a>$ stabilizer code, where d ≥ min(d₁, d₂).

The smallest distance-3 CSS code is the 7-qubit code, a $<a href=»/search/node/7%2C1%2C3″ title=»Search this site for content like “7,1,3”.» class=»freelink freelink-search notfound freelink-internal»>7,1,3</a>$ QECC created from the classical Hamming code (consisting of all sums of classical strings 1111000, 1100110, 1010101, and 1111111). The encoded $left|overline{0}rightrangle$ for this code consists of the superposition of all even-weight classical codewords and the encoded $left|overline{1}rightrangle$ is the superposition of all odd-weight classical codewords. The 7-qubit code is much studied because its properties make it particularly well-suited to fault-tolerant quantum computation.

Fault-Tolerance

Given a QECC, we can attempt to supplement it with protocols for performing fault-tolerant operations. The basic design principle of a fault-tolerant protocol is that an error in a single location — either a faulty gate or noise on a quiescent qubit — should not be able to alter more than a single qubit in each block of the quantum error-correcting code. If this condition is satisfied, t separate single-qubit or single-gate failures are required for a distance 2t + 1 code to fail.

Particular caution is necessary, as computational gates can cause errors to propagate from their original location onto qubits that were previously correct. In general, a gate coupling pairs of qubits allows errors to spread in both directions across the coupling.

The solution is to use transversal gates whenever possible. A transversal operation is one in which the ith qubit in each block of a QECC interacts only with the ith qubit of other blocks of the code or of special ancilla states. An operation consisting only of single-qubit gates is automatically transversal. A transversal operation has the virtue that an error occurring on the 3rd qubit in a block, say, can only ever propagate to the 3rd qubit of other blocks of the code, no matter what other sequence of gates we perform before a complete error-correction procedure.

In the case of certain codes, such as the 7-qubit code, a number of different gates can be performed transversally. Unfortunately, it does not appear to be possible to perform universal quantum computations using just transversal gates. We therefore have to resort to more complicated techniques. First we create special encoded ancilla states in a non-fault-tolerant way, but perform some sort of check on them (in addition to error correction) to make sure they are not too far off from the goal. Then we interact the ancilla with the encoded data qubits using gates from our stock of transversal gates and perform a fault-tolerant measurement. Then we complete the operation with a further transversal gate which depends on the outcome of the measurement.

Fault-Tolerant Gates

We will focus on stabilizer codes. Universal fault-tolerance is known to be possible for any stabilizer code, but in most cases the more complicated type of construction is needed for all but a few gates. The Pauli group P_k, however, can be performed transversally on any stabilizer code. Indeed, the set S^⊥  S of undetectable errors is a boon in this case, as it allows us to perform these gates. In particular, each coset S^⊥/S corresponds to a different logical Pauli operator (with S itself corresponding to the identity). On a stabilizer code, therefore, logical Pauli operations can be performed via a transversal Pauli operation on the physical qubits.

Stabilizer codes have a special relationship to a finite subgroup C_n of the unitary group U(2ⁿ) frequently called the Clifford group. The Clifford group on n qubits is defined as the set of unitary operations which conjugate the Pauli group P_n into itself; C_n can be generated by the Hadamard transform, the CNOT, and the single-qubit π/4 phase rotation diag(1, i). The set of stabilizer codes is exactly the set of codes which can be created by a Clifford group encoder circuit using ∣0⟩ ancilla states.

Some stabilizer codes have interesting symmetries under the action of certain Clifford group elements, and these symmetries result in transversal gate operations. A particularly useful fact is that a transversal CNOT gate (i.e., CNOT acting between the ith qubit of one block of the QECC and the ith qubit of a second block for all i) acts as a logical CNOT gate on the encoded qubits for any CSS code. Furthermore, for the 7-qubit code, transversal Hadamard performs a logical Hadamard, and the transversal π/4 rotation performs a logical  − π/4 rotation. Thus, for the 7-qubit code, the full logical Clifford group is accessible via transversal operations.

Unfortunately, the Clifford group by itself does not have much computational power: it can be efficiently simulated on a classical computer. We need to add some additional gate outside the Clifford group to allow universal quantum computation; a single gate will suffice, such as the single-qubit π/8 phase rotation diag(1, exp(iπ/4)). Note that this gives us a finite generating set of gates. However, by taking appropriate products, we get an infinite set of gates, one that is dense in the unitary group U(2ⁿ), allowing universal quantum computation.

The following circuit performs a π/8 rotation, given an ancilla state ∣ψ_π/8⟩ = ∣0⟩ + exp(iπ/4)∣1⟩:

Here P is the π/4 phase rotation diag(1, i), and X is the bit flip. The product is in the Clifford group, and is only performed if the measurement outcome is 1. Therefore, given the ability to perform fault-tolerant Clifford group operations, fault-tolerant measurements, and to prepare the encoded ∣ψ_π/8⟩ state, we have universal fault-tolerant quantum computation. A slight generalization of the fault-tolerant measurement procedure below can be used to fault-tolerantly verify the ∣ψ_π/8⟩ state, which is a  + 1 eigenstate of PX. Using this or another verification procedure, we can check a non-fault-tolerant construction.

Fault-Tolerant Measurement and Error Correction

Since all our gates are unreliable, including those used to correct errors, we will need some sort of fault-tolerant quantum error correction procedure. A number of different techniques have been developed. All of them share some basic features: they involve creation and verification of specialized ancilla states, and use transversal gates which interact the data block with the ancilla state.

The simplest method, due to Shor, is very general but also requires the most overhead and is frequently the most susceptible to noise. Note that the following procedure can be used to measure (non-fault-tolerantly) the eigenvalue of any (possibly multi-qubit) Pauli operator M: Produce an ancilla qubit in the state ∣ + ⟩ = ∣0⟩ + ∣1⟩. Perform a controlled-M operation from the ancilla to the state being measured. In the case where M is a multi-qubit Pauli operator, this can be broken down into a sequence of controlled-X, controlled-Y, and controlled-Z operations. Then measure the ancilla in the basis of ∣ + ⟩ and ∣ − ⟩ = ∣0⟩ − ∣1⟩. If the state is a  + 1 eigenvector of M, the ancilla will be ∣ + ⟩, and if the state is a  − 1 eigenvector, the ancilla will be ∣ − ⟩.

The advantage of this procedure is that it measures just M and nothing more. The disadvantage is that it is not transversal, and thus not fault-tolerant. Instead of the unencoded ∣ + ⟩ state, we must use a more complex ancilla state ∣00…0⟩ + ∣11…1⟩ known as a ‘cat’ state. The cat state contains as many qubits as the operator M to be measured, and we perform the controlled-X, —Y, or —Z operations transversally from the appropriate qubits of the cat state to the appropriate qubits in the data block. Since, assuming the cat state is correct, all of its qubits are either ∣0⟩ or ∣1⟩, the procedure either leaves the data state alone or performs M on it uniformly. A  + 1 eigenstate in the data therefore leaves us with ∣00…0⟩ + ∣11…1⟩ in the ancilla and a  − 1 eigenstate leaves us with ∣00…0⟩ + ∣11…1⟩. In either case, the final state still tells us nothing about the data beyond the eigenvalue of M. If we perform a Hadamard transform and then measure each qubit in the ancilla, we get either a random even weight string (for eigenvalue  + 1) or an odd weight string (for eigenvalue  − 1).

The procedure is transversal, so an error on a single qubit in the initial cat state or in a single gate during the interaction will only produce one error in the data. However, the initial construction of the cat state is not fault-tolerant, so a single gate error then could eventually produce two errors in the data block. Therefore, we must be careful and use some sort of technique to verify the cat state, for instance by checking if random pairs of qubits are the same. Also, note that a single phase error in the cat state will cause the final measurement outcome to be wrong (even and odd switch places), so we should repeat the measurement procedure multiple times for greater reliability.

We can then make a full fault-tolerant error correction procedure by performing the above measurement technique for each generator of the stabilizer. Each measurement gives us one bit of the error syndrome, which we then decipher classically to determine the actual error.

More sophisticated techniques for fault-tolerant error correction involve less interaction with the data but at the cost of more complicated ancilla states. A procedure due to Steane uses (forCSS codes) one ancilla in a logical $left|overline{0}rightrangle$ state of the same code and one ancilla in a logical $left|overline{0}rightrangle + left|overline{1}rightrangle$ state. A procedure due to Knill (for any stabilizer code) teleports the data qubit through an ancilla consisting of two blocks of the QECC containing an encoded Bell state $left|overline{00}rightrangle + left|overline{11}rightrangle$. Because the ancillas in Steane and Knill error correction are more complicated than the cat state, it is especially important to verify the ancillas before using them.

Threshold for Fault-Tolerance

In an unencoded protocol, even one error can destroy the computation, but a fully fault-tolerant protocol will give the right answer unless multiple errors occur before they can be corrected. On the other hand, the fault-tolerant protocol is larger, requiring more qubits and more time to do each operation, and therefore providing more opportunities for errors. If errors occur on the physical qubits independently at random with probability p per gate or timestep, the fault-tolerant protocol has probability of logical error for a single logical gate or timestep at most Cp², where C is a constant that depends on the design of the fault-tolerant circuitry (assume the quantum error-correcting code has distance 3, as for the 7-qubit code). When $p &lt; p_t = 1/C$, the fault-tolerance helps, decreasing the logical error rate. p_t is the threshold for fault-tolerant quantum computation. If the error rate is higher than the threshold, the extra overhead means that errors will occur faster than they can be reliably corrected, and we are better off with an unencoded system.

To further lower the logical error rate, we turn to a family of codes known as concatenated codes. Given a codeword of a particular $<a href=»/search/node/n%2C1″ title=»Search this site for content like “n,1”.» class=»freelink freelink-search notfound freelink-internal»>n,1</a>$ QECC, we can take each physical qubit and again encode it using the same code, producing an $<a href=»/search/node/n%5E2%2C1″ title=»Search this site for content like “n^2,1”.» class=»freelink freelink-search notfound freelink-internal»>n^2,1</a>$ QECC. We could repeat this procedure to get an n³-qubit code, and so forth. The fault-tolerant procedures concatenate as well, and after L levels of concatenation, the effective logical error rate is p_t(p/p_t)^2L (for a base code correcting 1 error). Therefore, if p is below the threshold p_t, we can achieve an arbitrarily good error rate ε per logical gate or timestep using only poly(logε) resources, which is excellent theoretical scaling.

Unfortunately, the practical requirements for this result are not nearly so good. The best rigorous proofs of the threshold to date show that the threshold is at least 2 × 10^− 5 (meaning one error per 50, 000 operations). Optimized simulations of fault-tolerant protocols suggest the true threshold may be as high as 5%, but to tolerate this much error, existing protocols require enormous overhead, perhaps increasing the number of gates and qubits by a factor of a million or more for typical computations. For lower physical error rates, overhead requirements are more modest, particularly if we only attempt to optimize for calculations of a given size, but are still larger than one would like.

Furthermore, these calculations make a number of assumptions about the physical properties of the computer. The errors are assumed to be independent and uncorrelated between qubits except when a gate connects them. It is assumed that measurements and classical computations can be performed quickly and reliably, and that quantum gates can be performed between arbitrary pairs of qubits in the computer, irrespective of their physical proximity. Of these, only the assumption of independent errors is at all necessary, and that can be considerably relaxed to allow short-range correlations and certain kinds of non-Markovian environments. However, the effects of relaxing these assumptions on the threshold value and overhead requirements have not been well-studied.

Category:Introductory Tutorials Category:Quantum Error Correction Category:Handbook of Quantum Information

Квантовая коррекция ошибок ( QEC ) используется в квантовых вычислениях для защиты квантовой информации от ошибок из-за декогеренции и другого квантового шума . Квантовая коррекция ошибок необходима, если кто-то хочет добиться отказоустойчивых квантовых вычислений, которые могут иметь дело не только с шумом в хранимой квантовой информации, но также с неисправными квантовыми вентилями, ошибочной квантовой подготовкой и ошибочными измерениями.

Классическая коррекция ошибок использует избыточность . Самый простой способ — сохранить информацию несколько раз, и — если впоследствии выяснится, что эти копии не совпадают — просто проголосуйте большинством; например, предположим, что мы копируем бит три раза. Предположим далее, что зашумленная ошибка искажает трехбитовое состояние, так что один бит равен нулю, а два других равны единице. Если предположить, что зашумленные ошибки независимы и возникают с некоторой вероятностью p , наиболее вероятно, что ошибка является однобитовой ошибкой, а переданное сообщение состоит из трех единиц. Возможно, что возникает двухбитовая ошибка и переданное сообщение равно трем нулям, но этот результат менее вероятен, чем вышеприведенный результат.

Копирование квантовой информации невозможно из -за теоремы о запрете клонирования . Эта теорема, кажется, представляет собой препятствие для формулирования теории квантовой коррекции ошибок. Но можно распространить информацию об одном кубите на сильно запутанное состояние нескольких ( физических ) кубитов. Питер Шор первым открыл этот метод формулирования кода квантовой коррекции ошибок путем сохранения информации об одном кубите в сильно запутанном состоянии из девяти кубитов. Код квантовой коррекции ошибок защищает квантовую информацию от ошибок ограниченной формы.

Классические коды с исправлением ошибок используют измерение синдрома, чтобы диагностировать, какая ошибка искажает закодированное состояние. Затем он может исправить ошибку, применив корректирующую операцию на основе синдрома. Квантовая коррекция ошибок также использует синдромные измерения. Он выполняет многокубитовое измерение, которое не нарушает квантовую информацию в закодированном состоянии, но извлекает информацию об ошибке. Измерение синдрома может определить, был ли поврежден кубит, и если да, то какой. Более того, исход этой операции ( синдром) сообщает нам не только о том, какой физический кубит был затронут, но и о том, каким из нескольких возможных способов он был затронут. Последнее на первый взгляд противоречит интуиции: поскольку шум произвольный, как может влияние шума быть одной из немногих различных возможностей? В большинстве кодов эффект либо битовый, либо знак ( фазы ), либо и то, и другое (соответствует матрицам Паули X , Z и Y ). Причина в том, что измерение синдрома имеет проективный эффект квантового измерения . Таким образом , даже если ошибка из — за шума было произвольным, оно может быть выражено в виде суперпозиции из базисных операций,базис ошибок (который здесь задается матрицами Паули и тождеством ). Измерение синдрома «вынуждает» кубит «решить», что определенная «ошибка Паули» «произошла», и синдром сообщает нам, какая именно, поэтому исправление ошибок может позволить тому же оператору Паули снова воздействовать на поврежденный кубит, чтобы отменить эффект ошибки.

Синдромное измерение сообщает нам как можно больше о произошедшей ошибке, но ничего не говорит о значении , которое хранится в логическом кубите, поскольку в противном случае измерение разрушило бы любую квантовую суперпозицию этого логического кубита с другими кубитами в квантовом кубите. компьютер , что предотвратит его использование для передачи квантовой информации.

Битовый флип-код

Код повторения работает в классическом канале, потому что классические биты легко измерить и повторить. Это перестает быть случаем для квантового канала, в котором из -за теоремы о запрете клонирования больше невозможно повторить один кубит три раза. Чтобы преодолеть это, необходимо использовать другой метод, впервые предложенный Ашером Пересом в 1985 году
^[1]
, такой как так называемый трехкубитовый битовый флип-код . Этот метод использует измерения запутанности и синдромов и сравним по производительности с кодом повторения.

Рассмотрим ситуацию, в которой мы хотим передать состояние отдельного кубита через шумный канал . Более того, предположим, что этот канал либо переворачивает состояние кубита, с вероятностью, или оставляет его без изменений. Действие на общем входе поэтому можно записать как .

Позволять быть передаваемым квантовым состоянием. При отсутствии протокола исправления ошибок переданное состояние с вероятностью будет правильно передано.. Однако мы можем улучшить это число, кодируя состояние в большее количество кубитов, таким образом, чтобы можно было обнаруживать и исправлять ошибки в соответствующих логических кубитах . В случае простого трехкубитового кода повторения кодирование заключается в отображениях а также . Состояние ввода кодируется в состояние . Это отображение может быть реализовано, например, с использованием двух вентилей CNOT, запутывающих систему с двумя вспомогательными кубитами, инициализированными в состоянии. ^[2] Закодированное состояние это то, что сейчас проходит по зашумленному каналу.

Канал действует на перевернув некоторое подмножество (возможно, пустое) своих кубитов. Ни один кубит не переворачивается с вероятностью, отдельный кубит переворачивается с вероятностью , два кубита переворачиваются с вероятностью , и все три кубита переворачиваются с вероятностью . Обратите внимание, что здесь сделано еще одно предположение о канале: мы предполагаем, чтодействует одинаково и независимо на каждом из трех кубитов, в которых теперь закодировано состояние. Теперь проблема состоит в том, как обнаруживать и исправлять такие ошибки, не повреждая при этом передаваемое состояние .

Предположим для простоты, что достаточно мала, чтобы пренебрежимо мала вероятность перевернуть более одного кубита. Затем можно определить, был ли перевернут кубит, без запроса передаваемых значений , задав вопрос, отличается ли один из кубитов от других. Это равносильно выполнению измерения с четырьмя различными результатами, соответствующими четырем проективным измерениям:

Это может быть достигнуто, например, путем измерения а потом . Это показывает, какие кубиты отличаются от других, без предоставления информации о состоянии самих кубитов. Если результат, соответствующий не применяется, коррекция не применяется, а если результат, соответствующий наблюдается, то вентиль Pauli X применяется к-й кубит. Формально эта процедура исправления соответствует применению следующей карты к выходу канала:

Обратите внимание, что, хотя эта процедура идеально корректирует вывод, когда канал вводит ноль или один переворот, если перевернуто более одного кубита, то вывод не корректируется должным образом. Например, если перевернуть первый и второй кубиты, то измерение синдрома даст результат, а третий кубит переворачивается вместо первых двух. Чтобы оценить эффективность этой схемы исправления ошибок для общего входа, мы можем изучить точность между входом и выход . Состояние выхода правильно, когда переворачивается не более одного кубита, что происходит с вероятностью , мы можем записать это как , где точками обозначены компоненты возникшие в результате ошибок, не исправленных протоколом должным образом. Следует, что

Эту точность следует сравнивать с соответствующей точностью, полученной без использования протокола исправления ошибок, которая, как было показано ранее, равна. Затем небольшая алгебра показывает, что точность после исправления ошибок выше, чем точность без исправления ошибок.. Обратите внимание, что это согласуется с рабочим предположением, которое было сделано при выводе протокола ( будучи достаточно маленьким).

Подпишите флип-код

Перевернутые биты — единственный вид ошибки в классическом компьютере, но есть еще одна возможность ошибки в квантовых компьютерах — переворот знака. Через передачу в канале относительный знак между а также может перевернуться. Например, кубит в состоянии может быть его знак перевернут на

Исходное состояние кубита

будет преобразован в состояние

В основе Адамара переворачивание битов становится переключением знака, а изменение знака — переключением битов. Позволятьбыть квантовым каналом, который может вызвать не более одного переворота фазы. Тогда битовый флип-код сверху может восстановить путем преобразования в базис Адамара до и после передачи через .

Код сокращения

Канал ошибки может вызвать либо переворот битов, либо смену знака (т. Е. Переворот фазы), либо и то, и другое. Оба типа ошибок можно исправить с помощью одного кода, и код Шора делает именно это. Фактически, код Шора исправляет произвольные однокубитовые ошибки.

Позволять быть квантовым каналом, который может произвольно повредить отдельный кубит. 1-й, 4-й и 7-й кубиты предназначены для переворота знака, а три группы кубитов (1,2,3), (4,5,6) и (7,8,9) предназначены для переворота битов. код. С кодом Шора состояние кубита превратится в произведение 9 кубитов , куда

Если с кубитом происходит ошибка переворота бита, синдромный анализ будет выполняться для каждого набора состояний (1,2,3), (4,5,6) и (7,8,9), а затем исправить ошибку. .

Если трехбитовая группа переключения (1,2,3), (4,5,6) и (7,8,9) рассматривается как три входа, то схема кода Шора может быть сокращена как код переключения знака. Это означает, что код Шора может также исправить ошибку переворота знака для одного кубита. ^[3]

Код Шора также может исправлять любые произвольные ошибки (как изменение битов, так и изменение знака) в одном кубите. Если ошибка моделируется унитарным преобразованием U, которое воздействует на кубит, тогда можно описать в виде

куда ,,, а также — комплексные константы, I — единица, а матрицы Паули имеют вид

Если U равно I , то ошибки не возникает. Есливозникает ошибка переворота битов. Есливозникает ошибка переворота знака. Еслитогда возникает как ошибка переворота битов, так и ошибка переворота знака. Из-за линейности следует, что код Шора может исправлять произвольные 1-кубитные ошибки. ^{[ требуется разъяснение ]}

Бозонные коды

Было сделано несколько предложений по хранению квантовой информации с исправлением ошибок в бозонных режимах. В отличие от двухуровневой системы, квантовый гармонический осциллятор имеет бесконечно много уровней энергии в одной физической системе. Коды для этих систем включают кот, ^{[4] [5] [6]} Готтесман-Китаева-Прескилла (GKP), ^[7] и биномиальные коды. ^{[8] [9]} Эти коды позволяют использовать преимущества избыточности в одной системе, а не дублировать множество двухуровневых кубитов.

Написанная на основе Фока простейшая биномиальная кодировка

где нижний индекс L указывает «логически закодированное» состояние. Тогда, если основным механизмом ошибки системы является стохастическое применение бозонного опускающего оператора соответствующие состояния ошибки а также соответственно. Поскольку кодовые слова включают только четное число фотонов, а состояния ошибки включают только нечетное число фотонов, ошибки могут быть обнаружены путем измерения четности числа фотонов в системе. ^{[8] [10]} Измерение нечетной четности позволит исправить это путем применения соответствующей унитарной операции без знания конкретного логического состояния кубита. Однако конкретный биномиальный код выше не устойчив к двухфотонным потерям.

Общие коды

В общем, квантовый код для квантового канала является подпространством , куда гильбертово пространство состояний, такое, что существует еще один квантовый канал с участием

куда является ортогональной проекцией на. Здесьназывается операцией коррекции .

Невырожденной код един для которых различных элементов набора корректируемых ошибок производства линейно независимых результатов при применении к элементам коды. Если отдельные исправимые ошибки дают ортогональные результаты, код считается чистым . ^[11]

Модели

Со временем исследователи придумали несколько кодов:

• 9-кубитовый код Питера Шора , также известный как код Шора, кодирует 1 логический кубит в 9 физических кубитов и может исправлять произвольные ошибки в одном кубите.
• Эндрю Стейн нашел код, который делает то же самое с 7 кубитами вместо 9, см. Код Стейна .
• Рэймонд Лафламм и его сотрудники обнаружили класс 5-кубитовых кодов, которые делают то же самое, а также обладают свойством отказоустойчивости . Код 5-кубит является наименьшим возможным код , который защищает одну логическую кубит от ошибок одного кубита.
• Обобщение техники, использованной Стейном для разработки 7-кубитового кода из классического [7, 4] кода Хэмминга , привело к созданию важного класса кодов, названных кодами CSS , названных в честь их изобретателей: AR Calderbank , Питер Шор и Эндрю Стейн . Согласно квантовой границе Хэмминга, для кодирования одного логического кубита и обеспечения произвольной коррекции ошибок в одном кубите требуется минимум 5 физических кубитов.
• Более общий класс кодов (включающий первые) — это коды-стабилизаторы, открытые Дэниелом Готтесманом ( [1] ) и А. Р. Калдербанком , Эриком Рейнсом , Питером Шором и Н. Дж. А. Слоаном ( [2] , [3] ); их также называют аддитивными кодами .
• Двумерный код Бэкона – Шора s представляет собой семейство кодов, параметризованных целыми числами m и n . В квадратной решетке расположены нм кубиты. ^[12]
• Более новая идея является Китаев «s топологические квантовые коды и более общая идея топологического квантового компьютера .
• Тодд Брун , Игорь Деветак и Мин-Сю Се также построили формализм стабилизатора с помощью запутывания как расширение стандартного формализма стабилизатора, который включает квантовую запутанность, разделяемую отправителем и получателем.

То, что эти коды действительно позволяют выполнять квантовые вычисления произвольной длины, является содержанием квантовой теоремы о пороге , найденной Майклом Бен-Ором и Дорит Аароновым , которая утверждает, что вы можете исправить все ошибки, если объедините квантовые коды, такие как коды CSS — т.е. перекодировать каждый логический кубит тем же кодом снова, и так далее, на логарифмически многих уровнях — при условии, что частота ошибок отдельных квантовых вентилей ниже определенного порога; в противном случае попытки измерить синдром и исправить ошибки привнесут больше новых ошибок, чем они исправят.

По состоянию на конец 2004 г. оценки этого порога показывают, что он может достигать 1–3% ^[13] при условии, что доступно достаточно много кубитов .

Экспериментальная реализация

Было несколько экспериментальных реализаций кодов на основе CSS. Первая демонстрация была с кубитами ЯМР. ^[14] Впоследствии были проведены демонстрации линейной оптики, ^[15] захваченных ионов, ^{[16] [17]} и сверхпроводящих ( трансмонных ) кубитов. ^[18]

В 2016 году впервые срок службы квантового бита был продлен за счет использования кода QEC. ^[19] Демонстрация коррекции ошибок была проведена на состояниях Шредингера-Кота, закодированных в сверхпроводящем резонаторе, и с использованием квантового контроллера, способного выполнять операции обратной связи в реальном времени, включая считывание квантовой информации, ее анализ и коррекцию его обнаруженные ошибки. Работа продемонстрировала, как система с квантовыми ошибками достигает точки безубыточности, в которой время жизни логического кубита превышает время жизни основных компонентов системы (физических кубитов).

Также были реализованы другие коды с исправлением ошибок, например код, предназначенный для коррекции потери фотонов, основного источника ошибок в схемах фотонных кубитов. ^{[20] [21]}

В 2021 году переплетение между двумя логическими кубитами, закодированными в топологических кодах квантовой коррекции ошибок, было впервые реализовано с использованием 10 ионов в квантовом компьютере с захваченными ионами . ^{[22] [23] В} 2021 году также была проведена первая экспериментальная демонстрация отказоустойчивости в одном логическом кубите системы захваченных ионов, т. Е. Демонстрация, для которой добавление коррекции ошибок способно подавить больше ошибок, чем вносится накладные расходы, необходимые для реализации исправления ошибок. ^{[24] [25]}

См. Также

• Обнаружение и исправление ошибок
• Мягкая ошибка

Ссылки

Библиография

• Дэниел Лидар и Тодд Брун, изд. (2013). Квантовая коррекция ошибок . Издательство Кембриджского университета.
• La Guardia, Джулиано Гадиоли, изд. (2020). Квантовая коррекция ошибок: симметричные, асимметричные, синхронизируемые и сверточные коды . Springer Nature.
• Фрэнк Гайтан (2008). Квантовая коррекция ошибок и отказоустойчивые квантовые вычисления . Тейлор и Фрэнсис.

• Фридман, Майкл Х .; Мейер, Дэвид А .; Луо, Фэн: Z ₂ — Систолическая свобода и квантовые коды. Математика квантовых вычислений , 287–320, Comput. Математика. Сер., Chapman & Hall / CRC, Бока-Ратон, Флорида, 2002.
• Фридман, Майкл Х .; Мейер, Дэвид А. (1998). «Проективные плоские и планарные квантовые коды» . Нашел. Comput. Математика . 2001 (3): 325–332. arXiv : квант-ph / 9810055 . Bibcode : 1998quant.ph.10055F .
• Лассен, Микаэль; Сабунку, Метин; Гек, Александр; Нисет, Жюльен; Лейкс, Герд; Cerf, Nicolas J .; Андерсен, Ульрик Л. (2010). «Квантовая оптическая когерентность может выдержать потери фотонов, используя квантовый код с непрерывной переменной, корректирующий стирание» . Природа Фотоника . 4 (1): 10. Bibcode : 2010NaPho … 4 … 10W . DOI : 10.1038 / nphoton.2009.243 .

Внешние ссылки

• Книл, Э. (2004). «Квантовые вычисления с очень шумными устройствами». Природа . 434 : 39–44. arXiv : квант-ph / 0410199 . Bibcode : 2005Natur.434 … 39K . DOI : 10,1038 / природа03350 . PMID  15744292 . S2CID  4420858 .
• Прорыв в области квантовых вычислений с проверкой ошибок ^{[ постоянная мертвая ссылка ]}
• «Топологическая квантовая коррекция ошибок» . Квантовый свет . Университет Шеффилда. 28 сентября 2018 г. — через YouTube .

Contents

Contents

Idea

General

Quantum error correction is concerned with ensuring the robustness of quantum computation against noise (as in classical error correction) and particularly against quantum noise and quantum decoherence (e.g. against bit flip errors).

From Ferris & Poulin 2013:

The basic principle of quantum error correction (QEC) is to encode information into the long-range correlations of entangled quantum many-body states in such a way that it cannot be accessed locally. When a local error affects the system, it leaves a detectable imprint—called the error syndrome. The decoding problem consists in inferring the recovery with greatest probability of success given the error syndrome. In general, this is a hard problem, but for well-chosen codes, it can be solved efficiently either exactly or heuristically.

From Steane 06:

Error correction is especially important in quantum computers, because efficient quantum algorithms make use of large scale quantum interference, which is fragile, i.e. sensitive to imprecision in the computer and to unwanted coupling between the computer and the rest of the world. This makes large scale quantum computation so difficult as to be practically impossible unless error correction methods are used. Indeed, before quantum error correction was discovered, it seemed that this fragility would forbid large scale quantum computation. The ability to correct a quantum computer efficiently without disturbing the coherence of the computation is highly non-intuitive, and was thought more or less impossible. The discovery of powerful error correction methods therefore caused much excitement, since it converted large scale quantum computation from a practical impossibility to a possibility.

From Devitt, Nemoto & Munro 2009:

Starting in 1995, several papers appeared, in rapid succession, proposing codes which were appropriate to perform error correction on quantum data (Sho95; Ste96a; CS96; LMPZ96; BSW96). This was a key theoretical development needed to convince the general community that quantum computation was indeed a possibility. Since this initial introduction, the progress in this field has been extensive.

From Zhu & Cross 20:

Although we are currently in an era of quantum computers with tens of noisy qubits, it is likely that a decisive, practical quantum advantage can only be achieved with a scalable, fault-tolerant, error-corrected quantum computer. Therefore, development of quantum error correction is one of the central themes of the next five to ten years.

Lucero 21:

Within the decade, Google aims to build a useful, error-corrected quantum computer. [⋯][cdots] Our journey to build an error-corrected quantum computer within the decade includes several scientific milestones, including building an error-corrected logical qubit.

Specifically on holographic quantum error correcting codes (see references below):

From Harlow 20:

The codes provided by AdS/CFT often come close to saturating theoretical bounds on the performance of quantum codes. It seems AdS/CFT may be a tool for discovering better quantum cryptography?

WVSB 20:

[[ holographic codes ]] could be promising candidates to circumvent our results and could possibly realise a universal set of unitary implementations of logical operators.

From CDCW 21:

There are a number of reasons to suspect that holographic codes may be of practical use for quantum computing.

Holographic codes can admit erasure thresholds comparable to that of the widely-studied surface code, and likewise for their threshold against Pauli errors. Their holographic structure also naturally leads to an organization of encoded qubits into a hierarchy of levels of protection from errors, which could be useful for applications which call for many qubits withvarying levels of protection. In particular, this is reminiscent of many schemes for magic state distillation – and indeed, the concatenated codes utilized for magic state distillation share a similar hierarchical structure to holographic codes. The layered structure of holographic codes is also reminiscent of memory architectures in classical computers, where it is useful to have different levels of short- and long-term memory. Although these codes have some notable drawbacks, in particular holographic stabilizer codes require nonlocal stabilizer generators, other codes such as concatenated codes suffer similar drawbacks and have still proven to be useful. Conversely, the stringent requirement of non-local stabilizer generators allows holographic codes to protect many more qubits than a topological code and in fact attain a finite nonzero encoding rate, which is typically not possible for topological codes. Nonetheless, many open questions remain about the usefulness of holographic codes for fault-tolerant quantum computing.

Quantum error correcting codes

The simple but important special case of passive correction of erasures may be handled by quantum error correcting codes:

Recall that a classical error correcting code on a finite set of states SS is, typically, a choice of injection of SS into some larger set, typically a Cartesian power

L↪codeP≔H×⋯×H
L overset{code}{hookrightarrow} P coloneqq H times cdots times H

(often considered in the form of linear codes, but classical nonetheless). In quantum physics the Cartesian product of sets of states is replaced by the tensor product of Hilbert spaces.

For ℒmathcal{L} a given Hilbert space of quantum states (finite-dimensional in practice), a quantum error correcting code is a choice of linear embedding (the code subspace) of ℋmathcal{H} into a larger Hilbert spaces, often an nn-fold tensor product of copies of some HH:

ℋlogicalqbits ↪codesubspacecode 𝒫≔ℋ (1)⊗⋯⊗ℋ (n)physicalqbits,
array{
underset{
{color{blue}logical}
atop
{color{blue}qbits}
}{
mathcal{H}
}
&
underoverset
{{color{blue}code} atop {color{blue} subspace}}
{;;;code;;;}
{
hookrightarrow
}
&
mathcal{P}
coloneqq
underset{
color{blue}
physical;qbits
}{
mathcal{H}^{(1)}
otimes
cdots
otimes
mathcal{H}^{(n)}
}
}
,,

such that the information in code(ψ)code(psi) in some of the tensor factors ℋ (i)mathcal{H}^{(i)} can be lost without obstructing the reconstruction of ψpsi (e.g. Rowell & Wang 17, Sec. 3.2.3).

(Often one demands additional properties, such as that a given set of linear operators OO (quantum observables) acting on ψ∈ℋpsi in mathcal{H} are implemented on code(ψ)code(psi) by combionations of operators that act non-trivially only on some of the tensor factors.)

While this is superficially analogous to a classical error correcting code, the crucial and subtle difference is that quantum error correction codes thus take place in a non-Cartesian symmetric monoidal category. For this reason, effects of quantum entanglement play a paramount role in quantum error correction codes.

Example

Specific examples

Bit flip codes

See at bit flip code.

A 3-qutrit code

The following is a simple illustrative example from Cleve, Gottesman & Lo 99, p. 1-2:

Consider a quantum system with a 3-dimensional space of quantum states:

ℋ≔ℂ 3=Span(|0⟩,|1⟩,|2⟩)
mathcal{H}
;coloneqq;
mathbb{C}^3
;=;
Spanbig(
leftvert 0 rightrangle,,
leftvert 1 rightrangle,,
leftvert 2 rightrangle
big)

and consider a code space inside 3 copies of this space given by the following linear map

ℋ ⟶AAAAcodeAAAA ℋ ⊗3 α|0⟩ + β|1⟩ + γ|2⟩ ↦ α13(|000⟩+|111⟩+|222⟩) + β13(|012⟩+|120⟩+|201⟩) + γ13(|021⟩+|102⟩+|210⟩)
array{
mathcal{H}
&
overset{
phantom{AAAA}
code
phantom{AAAA}
}{longrightarrow}&
mathcal{H}^{otimes 3}
\
array{
& alpha leftvert 0 rightrangle
\
+ & beta leftvert 1 rightrangle
\
+ & gamma leftvert 2 rightrangle
}
&
mapsto
&
array{
& alpha
tfrac{1}{sqrt{3}}
big(
leftvert 000 rightrangle
+
leftvert 111 rightrangle
+
leftvert 222 rightrangle
big)
\
+ & beta
tfrac{1}{sqrt{3}}
big(
leftvert 012 rightrangle
+
leftvert 120 rightrangle
+
leftvert 201 rightrangle
big)
\
+ & gamma
tfrac{1}{sqrt{3}}
big(
leftvert 021 rightrangle
+
leftvert 102 rightrangle
+
leftvert 210 rightrangle
big)
}
}

This code corrects errors consisting of the loss of one of the three copies, in the following sense:

There is a linear operator acting only on two of the three copies, explicitly given (ADH 14 (3.6)) by

ℋ⊗ℋ ⟶U (12) ℋ⊗ℋ |00⟩ ↦ |00⟩ |01⟩ ↦ |12⟩ |02⟩ ↦ |21⟩ |10⟩ ↦ |22⟩ |11⟩ ↦ |01⟩ |12⟩ ↦ |10⟩ |20⟩ ↦ |11⟩ |21⟩ ↦ |20⟩ |22⟩ ↦ |02⟩
array{
mathcal{H} otimes mathcal{H}
&
overset{
;;;;;;
U^{(12)}
;;;;;;
}{longrightarrow}
&
mathcal{H} otimes mathcal{H}
\
leftvert 00 rightrangle &mapsto& leftvert 00 rightrangle
\
leftvert 01 rightrangle &mapsto& leftvert 12 rightrangle
\
leftvert 02 rightrangle &mapsto& leftvert 21 rightrangle
\
leftvert 10 rightrangle &mapsto& leftvert 22 rightrangle
\
leftvert 11 rightrangle &mapsto& leftvert 01 rightrangle
\
leftvert 12 rightrangle &mapsto& leftvert 10 rightrangle
\
leftvert 20 rightrangle &mapsto& leftvert 11 rightrangle
\
leftvert 21 rightrangle &mapsto& leftvert 20 rightrangle
\
leftvert 22 rightrangle &mapsto& leftvert 02 rightrangle
}

such that

(U (12)⊗id (3))∘code(|ψ⟩)=|ψ⟩⊗13(|00⟩+|11⟩+|22⟩)
big( U^{(12)} otimes id^{(3)} big)
circ
code
big(
leftvert psi rightrangle
big)
;; = ;;
leftvert psi rightrangle
,
otimes
,
tfrac{1}{sqrt{3}}
left(
leftvert 00 rightrangle
+
leftvert 11 rightrangle
+
leftvert 22 rightrangle
right)

The HaPPY code

The HaPPY code is a quantum error correction code (a class of such codes really, indexed by a “cutoff” natural number) which is thought to exhibit characteristic properties akin to the encoding of bulk-quantum states by boundary-states expected in the AdS/CFT correspondence. In particular, the HaPPY code (or rather the tensor network that defines it) exhibits a discretized form of the Ryu-Takayanagi formula for holographic entanglement entropy.

Concretely, the the HaPPY code subspace is the image of the linear map formed by:

1. picking a perfect tensor TT of rank 6;

2. picking a finite cutoff of the pentagonal tesselation of the hyperbolic plane;

3. regarding its Poincaré dual graph as a tensor network (string diagram in finite-dimensional vector spaces) by

   1. assigning TT to each vertex at the center of the pentagons (show in blue), with 5 of its indices contracted with its neighbours in the hyperbolic plane,

   2. and its 6th uncontracted index remaining as an input (shown in red);

4. regarding the uncontracted edges at the cutoff boundary as output (shown in white)

and thus as a linear map from the tensor product over the bulk-vertices to the tensor product over the edges sticking out over the boundary.

Majorana dimer codes

See at Majorana dimer code.

Classes of examples

• stabilizer code

• error correcting code

• dynamic lifting

• repeat-until-success computing

• quantum entanglement

• entanglement entropy, holographic entanglement entropy

• quantum computing, topological quantum computing

• quantum secret sharing

• tensor network

References

General

The idea of quantum encryption based on the no-cloning theorem originates with:

• Stephen Wiesner, Conjugate Coding, circulated in the 1960s, finally published in ACM SIGACT News 15 1 (1983) 78–88 (original pdf, doi:10.1145/1008908.1008920)

Original articles on quantum error correcting codes:

• Peter W. Shor, Scheme for reducing decoherence in quantum computer memory, Phys. Rev. A 52, R2493(R) 1995 (doi:10.1103/PhysRevA.52.R2493)

• Andrew M. Steane, Error Correcting Codes in Quantum Theory, Phys. Rev. Lett. 77, 793 1996 (doi:10.1103/PhysRevLett.77.793)

• Robert Calderbank, Peter W. Shor, Good Quantum Error-Correcting Codes Exist, Phys. Rev. A, Vol. 54, No. 2, pp. 1098-1106, 1996 (doi:10.1103/PhysRevA.54.1098)

• Raymond Laflamme, Cesar Miquel, Juan Pablo Paz, Wojciech H. Zurek, Perfect Quantum Error Correction Code, Phys. Rev. Lett., 77:198, 1996 (arXiv:quant-ph/9602019)

• Charles H. Bennett, David P. DiVincenzo, John A. Smolin, William K. Wootters, Mixed State Entanglement and Quantum Error Correction, Phys. Rev. A54:3824-3851, 1996 (doi:10.1103/PhysRevA.54.3824)

• Andrew M. Steane, Multiple Particle Interference and Quantum Error Correction, Proc. Roy. Soc. Lond. A452 (1996) 2551 (arXiv:quant-ph/9601029)

• Emanuel Knill, Raymond Laflamme, A Theory of Quantum Error-Correcting Codes, Phys. Rev. Lett. 84:2525-2528, 2000 (arXiv:quant-ph/9604034)

Realization that quantum error correcting codes could make quantum computation practically feasible:

• Emanuel Knill, Raymond Laflamme, Wojciech H. Zurek, Resilient Quantum Computation: Error Models and Thresholds, Proceedings of the Royal Society A 454 1969 (1998) [arXiv:quant-ph/9702058]

• John Preskill, Fault-tolerant quantum computation, in: Introduction to Quantum Computation and Information, World Scientific (1998) [[arXiv:quant-ph/9712048, doi:10.1142/3724]]

• John Preskill, Reliable Quantum Computers, Proc. Roy. Soc. Lond. A 454 (1998) 385-410 [[arXiv:quant-ph/9705031, doi:10.1098/rspa.1998.0167]]

• Daniel Gottesman, Theory of fault-tolerant quantum computation, Phys. Rev. A 57 (1998) 127-137 [[doi:10.1103/PhysRevA.57.127]]

• Dorit Aharonov, Michael Ben-Or, Fault-Tolerant Quantum Computation With Constant Error Rate, SIAM J. Comput., 38 4 (2008) 1207–1282 [arXiv:quant-ph/9906129, doi:10.1007/978-3-642-32512-0_31]

• Daniel Gottesman, Fault-Tolerant Quantum Computation, Physics in Canada 63 4 (2007) 183-189 [[arXiv:quant-ph/0701112]]

• Dorit Aharonov, Michael Ben-Or, Fault-Tolerant Quantum Computation With Constant Error Rate, SIAM J. Comput. 38 4 (2008) 1207–1282 (arXiv:quant-ph/9906129, doi:10.1137/S0097539799359385)

• Panos Aliferis, Daniel Gottesman, John Preskill, Quantum accuracy threshold for concatenated distance-3 codes, Quant. Inf. Comput. 6 (2006) 97-165 (arXiv:quant-ph/0504218)

• Earl T. Campbell, Barbara M. Terhal, Christophe Vuillot: Roads towards fault-tolerant universal quantum computation, Nature 549 (2017) 172–179 [[doi:10.1038/nature23460]]

Operator algebraic formulation of quantum error correction:

• David Kribs, Raymond Laflamme, David Poulin, A Unified and Generalized Approach to Quantum Error Correction, Phys. Rev. Lett. 94, 180501 (2005) (arXiv:quant-ph/0412076)

• David W. Kribs, Raymond Laflamme, David Poulin, Maia Lesosky, Operator quantum error correction, Quant. Inf. & Comp., 6 (2006), 383-399 (arXiv:quant-ph/0504189)

on quantum observables:

• Cédric Bény, Achim Kempf, David W. Kribs, Generalization of Quantum Error Correction via the Heisenberg Picture, Phys. Rev. Lett. 98, 100502 – Published 7 March 2007 (doi:10.1103/PhysRevLett.98.100502, arXiv:quant-ph/0608071)

• Cédric Bény, Achim Kempf, David W. Kribs, Quantum Error Correction of Observables, Phys. Rev. A 76, 042303 (2007) (arXiv:0705.1574)

Introduction and survey:

• Alexei Kitaev, Quantum computations: algorithms and error correction, Russian Mathematical Surveys, 52 6 (1997) [doi:10.1070/RM1997v052n06ABEH002155, pdf]

• Michael A. Nielsen, Isaac L. Chuang, Chapter 10 of: Quantum computation and quantum information, Cambridge University Press (2000) [doi:10.1017/CBO9780511976667, pdf, pdf]

• Simeon Ball, Aina Centelles, Felix Huber, Quantum error-correcting codes and their geometries (arXiv:2007.05992)

• Andrew M. Steane, A Tutorial on Quantum Error Correction, in: Proceedings of the International School of Physics “Enrico Fermi”, course CLXII, “Quantum Computers, Algorithms and Chaos” (2006) [pdf, pdf]

• Isaac L. Chuang, Quantum error correction, Chapter 7 in: Quantum Machines: Measurement and Control of Engineered Quantum Systems Lecture Notes of the Les Houches Summer School 96 (2011) 273–320 [doi:10.1093/acprof:oso/9780199681181.003.0007]

• Simon J. Devitt, Kae Nemoto, William J. Munro, Quantum Error Correction for Beginners, Rep. Prog. Phys. 76 (2013) 076001 [arXiv:0905.2794, doi:10.1088/0034-4885/76/7/076001]

• Eric Rowell, Zhenghan Wang, Section 3.2.3 of: Mathematics of Topological Quantum Computing, Bull. Amer. Math. Soc. 55 (2018), 183-238 (arXiv:1705.06206, doi:10.1090/bull/1605)

• Scott Aaronson, Chapter 27 of: Introduction to Quantum Information Science (2018) [pdf, webpage]

• Joschka Roffe, Quantum Error Correction: An Introductory Guide, Contemporary Physics 2019 (arXiv:1907.11157)

• Bei Zeng, Xie Chen, Duan-Lu Zhou, Xiao-Gang Wen:

  Sec. 3 of: Quantum Information Meets Quantum Matter – From Quantum Entanglement to Topological Phases of Many-Body Systems, Quantum Science and Technology (QST), Springer (2019) [[arXiv:1508.02595, doi:10.1007/978-1-4939-9084-9]]

• Guanyu Zhu, Andrew Cross, Hardware-aware approach for fault-tolerant quantum computation, IBM Research Blog, September 2, 2020

See also:

• Wikipedia, Quantum error correction

In the context of quantum secret sharing:

• Richard Cleve, Daniel Gottesman, Hoi-Kwong Lo, How to share a quantum secret, Phys. Rev. Lett. 83 (1999) 648-651 (arXiv:quant-ph/9901025)

On (in-)compatibility of quantum error correction with universality of quantum gates (Eastin-Knill theorem):

• Bryan Eastin, Emanuel Knill, Restrictions on Transversal Encoded Quantum Gate Sets, Phys. Rev. Lett. 102, 110502 (2009) (arXiv:0811.4262)

• Paul Webster, Michael Vasmer, Thomas R. Scruby, Stephen D. Bartlett, Universal Fault-Tolerant Quantum Computing with Stabiliser Codes (arXiv:2012.05260)

On continuous variable quantum codes:

• Samuel L. Braunstein, Peter van Loock, §IV.C in: Quantum information with continuous variables, Rev. Mod. Phys. 77 2 (2005) 513 [arXiv:quant-ph/0410100, doi:10.1103/RevModPhys.77.513]

• Samuel L. Braunstein, Arun K. Pati, Quantum Information with Continuous Variables, Springer (2003) [doi:10.1007/978-94-015-1258-9]

• Allan D. C. Tosta, Thiago O. Maciel, Leandro Aolita, Grand Unification of continuous-variable codes [arXiv:2206.01751]

In relation to the SYK model:

• Shao-Kai Jian, Chunxiao Liu, Xiao Chen, Brian Swingle, Pengfei Zhang, Quantum error as an emergent magnetic field (arXiv:2106.09635)

In relation to continuous symmetries:

• Zi-Wen Liu, Sisi Zhou, Approximate symmetries and quantum error correction (arXiv:2111.06355)

Further developments:

• Mackenzie H. Shaw, Andrew C. Doherty, Arne L. Grimsmo, Stabilizer subsystem decompositions for single- and multi-mode Gottesman-Kitaev-Preskill codes [arXiv:2210.14919]

On relevant classical control mechanisms:

• Hideo Mabuchi, Continuous quantum error correction as classical hybrid control, New J. Phys. 11 (2009) 105044 [doi:10.1088/1367-2630/11/10/105030]

• Alexandru Paler, Daniel Herr, Simon J. Devitt, Really Small Shoe Boxes — On Realistic Quantum Resource Estimation, Computer 52 6 (2019) [arXiv:1902.08104, doi:10.1109/MC.2019.2908621]

Experimental realization

Realization of quantum error correction in experiment, hence in actual quantum computers:

• D. G. Cory, M. D. Price, W. Maas, Emanuel Knill, Raymond Laflamme, Wojchiek H. Zurek, T. F. Havel, and S. S. Somaroo, Experimental Quantum Error Correction, Phys. Rev. Lett. 81, 2152 (1998) (doi:10.1103/PhysRevLett.81.2152)

• Daniel Nigg, Markus Mueller, Esteban A. Martinez, Philipp Schindler, Markus Hennrich, Thomas Monz, Miguel A. Martin-Delgado, Rainer Blatt,

  Experimental Quantum Computations on a Topologically Encoded Qubit, Science 18 Jul 2014: Vol. 345, Issue 6194, pp. 302-305 (arXiv:1403.5426, doi:10.1126/science.1253742)

  (via methods from topological quantum computation)

• Adrian Cho, The biggest flipping challenge in quantum computing, Science News Jul. 9, 2020

  (exposition)

• Y. Ma et al. Error-transparent operations on a logical qubit protected by quantum error correction, Nature Physics volume 16, pages 827–831 (2020) (doi:10.1038/s41567-020-0893-x)

• Ming Gong et al. Experimental exploration of five-qubit quantum error correcting code with superconducting qubits, National Science Review, nwab011 (2021) (doi:10.1093/nsr/nwab011)

  survey in:

  EurekaAlert, Science China Press: Demonstration of the universal quantum error correcting code with superconducting qubits, March 2021 (2021-03/scp-dot031521)

• Erik Lucero (Google), Unveiling our new Quantum AI campus, May 18, 2021

  (outlook)

• Th. Monz et al., Demonstration of fault-tolerant universal quantum gate operations, Nature 605 (2022) 675–680 [[doi:10.1038/s41586-022-04721-1]]

Via holographic tensor networks

First quantum error correcting codes associated with planar bulk/boundary systems:

• S. B. Bravyi, Alexei Kitaev, Quantum codes on a lattice with boundary (arXiv:quant-ph/9811052)

• Michael Freedman, David A. Meyer, Projective Plane and Planar Quantum Codes, Found. Comput. Math. 1, 325–332 (2001) (arXiv:quant-ph/9810055, doi:10.1007/s102080010013)

First suggestion relating quantum error correction to black hole entropy:

• Erik Verlinde, Herman Verlinde, Black Hole Entanglement and Quantum Error Correction, J. High Energ. Phys. 2013, 107 (2013) (arXiv:1211.6913, doi:10.1007/JHEP10(2013)107)

Introducing the idea of quantum error correcting codes given by tensor network states:

• Andrew J. Ferris, David Poulin, Tensor Networks and Quantum Error Correction, Phys. Rev. Lett. 113, 030501 (2014) (arXiv:1312.4578)

• Dave Bacon, Steven T. Flammia, Aram W. Harrow, Jonathan Shi, Sparse Quantum Codes from Quantum Circuits, Proc. of STOC ‘15, pp. 327-334 (2015); IEEE Transactions on Information Theory, vol 63, no 4, pp 2464-2479, April 2017 (arXiv:1411.3334)

following observations in

• Brian Swingle, Entanglement Renormalization and Holography, Phys. Rev. D 86, 065007 (2012) (arXiv:0905.1317)

• Brian Swingle, Constructing holographic spacetimes using entanglement renormalization (arXiv:1209.3304, spire:1185813)

Interpretation of holographic tensor networks encoding holographic entanglement entropy in models for AdS2-CFT1 duality as quantum error correcting codes:

• Ahmed Almheiri, Xi Dong, Daniel Harlow, Bulk Locality and Quantum Error Correction in AdS/CFT, JHEP 1504:163,2015 (arXiv:1411.7041, doi:10.1007/JHEP04(2015)163)

  (using Bény-Kempf-Kribs 06)

with precursor observations in

• Beni Yoshida, Information storage capacity of discrete spin systems, Annals of Physics 338, 134 (2013) (arXiv:1111.3275)

  (focus on classical error correcting codes)

• Jose I. Latorre, German Sierra, Holographic codes (arXiv:1502.06618)

and concrete implementation by the HaPPY code:

• Fernando Pastawski, Beni Yoshida, Daniel Harlow, John Preskill, Holographic quantum error-correcting codes: Toy models for the bulk/boundary correspondence, JHEP 06 (2015) 149 (arXiv:1503.06237)

and possibly more generally:

• Daniel Harlow, The Ryu–Takayanagi Formula from Quantum Error Correction, Comm. Math. Phys. 354 (2017) 865–912 [doi:10.1007/s00220-017-2904-z, arXiv:1607.03901]

Introduction of the more general Majorana dimer code:

• Alexander Jahn, Marek Gluza, Fernando Pastawski, Jens Eisert, Majorana dimers and holographic quantum error-correcting codes, Phys. Rev. Research 1, 033079 (2019) (arXiv:1905.03268)

Exposition and review:

• John Preskill, Is spacetime a quantum error-correcting code?, talk at KITP 2015 (pdf, pdf)

• Daniel Harlow, TASI Lectures on the Emergence of Bulk Physics in AdS/CFT, PoS TASI2017 (2018) 002 (arXiv:1802.01040, doi:10.22323/1.305.0002)

• Pratik Rath, Aspects of Holography And Quantum Error Correction, 2020 (pdf, pdf)

• Melanie Swan, Renato P dos Santos, Frank Witte, The AdS/CFT Correspondence and Holographic Codes (doi:10.1142/9781786348210_0013, doi:10.1142/9781786348210_0014), Part 5 in: Between Science and Economics, Volume 2: Quantum Computing Physics, Blockchains, and Deep Learning Smart Networks, World Scientific 2020 (doi:10.1142/q0243)

• Daniel Harlow, Computation and Holography, talk at Snowmass Computational Frontier Workshop 2020 (pdf, pdf)

• Alexander Jahn, Jens Eisert, Holographic tensor network models and quantum error correction: A topical review (arXiv:2102.02619)

• Tanay Kibe, Prabha Mandayam, Ayan Mukhopadhyay, Holographic spacetime, black holes and quantum error correcting codes: A review (arXiv:2110.14669)

Further discussion of holographic quantum error correcting codes:

• Henrique Lazari, Reginaldo Palazzo Jr., Geometrically uniform hyperbolic codes, Comput. Appl. Math. vol.24 no.2 Petrópolis 2005 (doi:10.1590/S0101-82052005000200002)

• Enrico M. Brehm, Benedikt Richter, Classical Holographic Codes, Phys. Rev. D 96, 066005 (2017) (arXiv:1609.03560)

• Fernando Pastawski, John Preskill, Code properties from holographic geometries, Phys. Rev. X 7, 021022 (2017) (arXiv:1612.00017)

• Robert J. Harris, Nathan A. McMahon, Gavin K. Brennen, Thomas M. Stace, Calderbank-Steane-Shor Holographic Quantum Error Correcting Codes, Phys. Rev. A 98, 052301 (2018) (arXiv:1806.06472)

• Tamara Kohler, Toby Cubitt, Toy Models of Holographic Duality between local Hamiltonians, J. High Energy Phys. 2019:17 (2019) (arXiv:1810.08992)

• Tobias J. Osborne, Deniz E. Stiegemann, Dynamics for holographic codes, J. High Energ. Phys. 2020, 154 (2020) (arXiv:1706.08823)

• Martina Gschwendtner, Robert König, Burak Şahinoğlu & Eugene Tang, Quantum error-detection at low energies, Journal of High Energy Physics volume 2019, Article number: 21 (2019) (arXiv:1902.02115)

• Nathan A. McMahon, Gavin K. Brennen, Thomas M. Stace, Robert J. Harris, Elliot Coupe, Decoding Holographic Codes with an Integer Optimisation Decoder (arXiv:2008.10206)

• Terry Farrelly, Robert J. Harris, Nathan A. McMahon, Thomas M. Stace, Tensor-network codes (arXiv:2009.10329)

• ChunJun Cao, Brad Lackey, Approximate Bacon-Shor Code and Holography (arXiv:2010.05960)

• Sam Cree, Kfir Dolev, Vladimir Calvera, Dominic J. Williamson, Fault-tolerant logical gates in holographic stabilizer codes are severely restricted (arXiv:2103.13404)

• Robert de Mello Koch, Eunice Gandote, Nirina Hasina Tahiridimbisoa, Hendrik J.R. Van Zyl, Quantum Error Correction and Holographic Information from Bilocal Holography (arXiv:2106.00349)

• Chris Akers, Geoff Penington, Quantum minimal surfaces from quantum error correction (arXiv:2109.14618)

• ChunJun Cao, Brad Lackey, Quantum Lego: Building Quantum Error Correction Codes from Tensor Networks, PRX Quantum 3 020332 (2022) [[arXiv:2109.08158, doi:10.1103/PRXQuantum.3.020332]]

• Jason Pollack, Patrick Rall, Andrea Rocchetto, Understanding holographic error correction via unique algebras and atomic examples, Journal of High Energy Physics, 56 (2022) [[arXiv:2110.14691]]

• Dmitry S. Ageev, Exploring uberholography [arXiv:2208.07387]

Understanding in terms of the eigenstate thermalization hypothesis:

• Ning Bao, Newton Cheng, Eigenstate Thermalization Hypothesis and Approximate Quantum Error Correction, JHEP 08 (2019) 152 (arXiv:1906.03669)

In relation to holographic Renyi entropy:

• Chris Akers, Pratik Rath, Holographic Renyi entropy from quantum error correction, J. High Energ. Phys. 2019, 52 (2019) (arXiv:1811.05171)

From tesselations of higher-dimensional hyperbolic space:

• Vivien Londe, Anthony Leverrier, Golden codes: quantum LDPC codes built from regular tessellations of hyperbolic 4-manifolds (arXiv:1712.08578)

In view of black hole thermodynamics:

• Verlinde & Verlinde 2012

• Ahmed Almheiri, Holographic Quantum Error Correction and the Projected Black Hole Interior (arXiv:1810.02055)

• Isaac H. Kim, Eugene Tang, John Preskill, The ghost in the radiation: Robust encodings of the black hole interior, JHEP 2020, 31 (2020) (arXiv:2003.05451)

• Chris Akers, Netta Engelhardt, Daniel Harlow, Geoff Penington, Shreya Vardhan, The black hole interior from non-isometric codes and complexity [arXiv:2207.06536]

• Daniel Harlow, A theory of the black hole interior, talk at Strings 2022 [indico:4940817/]

Discussion of gauge symmetry of holographic tensor networks and their quantum error correcting codes:

• Kfir Dolev, Vladimir Calvera, Sam Cree, Dominic J. Williamson, Gauging the bulk: generalized gauging maps and holographic codes (arXiv:2108.11402)

Relation of quantum error correcting codes to the Monster vertex operator algebra and more generally to 2d SCFT and string theory:

• Jeffrey A. Harvey, Gregory W. Moore, Moonshine, Superconformal Symmetry, and Quantum Error Correction, J. High Energ. Phys. 2020, 146 (2020). (arXiv:2003.13700)

In relation to the large N limit:

• Alexey Milekhin, Quantum error correction and large NN (arXiv:2008.12869)

In relation to renormalization group flow:

• Keiichiro Furuya, Nima Lashkari, Mudassir Moosa, Renormalization group and approximate error correction (arXiv:2112.05099)

Musings on possible implications on relations between quantum gravity and quantum information:

• Simons Foundation, It from Qubit: Simons Collaboration on Quantum Fields, Gravity and Information

• Iulia Georgescu, Strings and qubits, Nature Reviews Physics volume 1, page 477 (2019) (doi:s42254-019-0087-6)

• Natalie Wolchover, How Space and Time Could Be a Quantum Error-Correcting Code, Quanta Magazine, Jan. 3 2019

• Tom Banks, Holographic Space-time and Quantum Information (arXiv:2001.08205)

• ChunJun Cao, From Quantum Codes to Gravity: A Journey of Gravitizing Quantum Mechanics (arXiv:2112.00199)