Physics Computer Science Medicine
ComputerScience,1970-2008-Computer Science-2003.jsonl.gz.gz
Computer Science
065a21633e8490a56b3a82eb7142100f1456a3b9
Description of a quantum convolutional code

We describe a quantum error correction scheme aimed at protecting a flow of quantum information over long distance communication. It is largely inspired by the theory of classical convolutional codes which are used in similar circumstances in classical communication. The particular example shown here uses the stabilizer formalism, which provides an explicit encoding circuit. An associated error estimation algorithm is given explicitly and shown to provide the most likely error over any memoryless quantum channel, while its complexity grows only linearly with the number of encoded qubits.

We describe a quantum error correction scheme aimed at protecting a flow of quantum information over long distance communication. It is largely inspired by the theory of classical convolutional codes which are used in similar circumstances in classical communication. The particular example shown here uses the stabilizer formalism, which provides an explicit encoding circuit. An associated error estimation algorithm is given explicitly and shown to provide the most likely error over any memoryless quantum channel, while its complexity grows only linearly with the number of encoded qubits. In recent years, the discovery and development of quantum computation and communication has shed new light on quantum physics. The potential applications of these new fields encompass a wide variety of subjects, ranging from unconditionally secure secret key generation protocols [1] to efficient integer factoring algorithms [2] or enhancement of communication complexity [3]. However, the practical realization of such protocols and algorithms remains a very involved task mainly because of the inherent instability of quantum superpositions [4] as well as intrinsic imprecisions of the physical devices that process quantum information. These errors wipe out the quantum superpositions together with entanglement, which are usually seen as key resources of the power of quantum algorithms and protocols [5]. Hence, protecting the quantum nature of information became one of the most important challenges to prove the feasibility of quantum computers. The discovery of quantum error correction schemes [6,7] notably opened the future of large scale quantum information processing: a certain, but unfortunately very small, degree of imprecision can be tolerated at each step of a quantum transformation and still allow a speed-up over classical information processing [8,9]. However, building a fault-tolerant quantum computer remains largely out of reach of the present day practical realizations, principally because of the large number of physical qubits required to account for the error correction.
On the other hand, quantum cryptography and more generally the field of quantum communication seems more promising in a near future. Some quantum key distribution protocols have been implemented and the associated devices seem to be close to commercialization [10]. Within this context, we construct a new family of codes -quantum convolutional codes -aimed at protecting a stream of quantum information in a long distance communication. They are the correct generalization to the quantum domain of their classical analogues, and hence inherit their most important properties. First, they have a maximum likelihood error estimation algorithm for all memoryless channels with a complexity growing linearly with the number of encoded qubits. This is an impor-tant issue since finding the most likely error -a strategy which allows to determine the most likely sent codeword -is in general a hard task: for a generic family of block codes with constant rate, the maximum likelihood error estimation algorithm has a complexity growing exponentially with the number of encoded qubits. Hence, generic block codes rapidly require to employ suboptimal error estimation procedures which, as a consequence, do not exploit the whole error correcting capabilities of the code. Moreover, our algorithm can easily handle variations in the properties of the communication channel (i.e. a change in the single qubit error probabilities). The second advantage of quantum convolutional codes is their ability to perform the encoding of the qubits online (i.e. as they arrive in the encoder). Thus, it is not necessary to wait for all the qubits to be ready to start sending the encoded state through the communication channel: it reduces the overall processing time of the qubits which is an additional source of decoherence. Note that an attempt at defining quantum convolutional codes has been made some time ago [11,12], but missed some crucial points concerning the error estimation algorithm as well as error propagation properties.
In this letter, we deal with a specific example drawn from our general theory. We construct a quantum convolutional code achieving a rate equal to 1/5: we explain how to encode and decode a stream of qubits efficiently, and we expose the maximum likelihood error estimation algorithm. This will give all the necessary intuition to understand how to generalize the present results to a wider framework [13].
Description of the code -The particular code we wish to present is best described by using the stabilizer formalism [14]. This provides a simple way to understand the encoding and decoding operations. Moreover, the error syndromes can be easily identified, which considerably simplifies the description of the error estimation algorithm. We use the following standard notations for the Pauli operators acting on a single qubit: so that ZX = Y . The identity matrix will be denoted by I. Since convolutional codes are designed to deal with a stream of information qubits, the number of generators of the stabilizer group will possibly be infinite. However in practice, transmission starts and ends at a given time, which means that we only consider generators made of a finite number of Pauli operators. The code subspace is described by the generators of its stabilizer group, S. These generators are given by: It is easy to check that all the generators commute and are independent. Thus, the code subspace (i.e. the largest common eigenspace of the generators with eigenvalue +1) is non-trivial. An important point to address when considering stabilizer codes is the ability to manipulate encoded information. Namely, we want to find the encoded Pauli operators X i , Z i corresponding to logical qubit i. These operators must satisfy the following relations: where N (S) denotes the normalizer of S. Equation (3) states that the encoded Pauli operators leave the code subspace globally invariant, but have a non-trivial action on its elements, while the Equations (4-6) ensure that manipulating qubit i does not affect other qubits. There exists a great choice of different sets of such operators, however they are not equivalent in the perspective of effectively manipulating the encoded quantum information in an easy way: in practice only those with a small number of terms different from the identity are useful. For our particular example, such set exists and has a structure invariant by a shift of five qubits: Hence, a unitary transformation on a single encoded qubit will in general be implemented by a unitary transformation on five physical qubits. At this point, one can wonder what in this code differs from a generic block code. The answer to this question comes from the particular structure of the stabilizer generators: beside M 0 and M ∞ , the generators of the stabilizer group can be casted into sets of constant size (e.g. four), each set acting on a fixed number (e.g. seven) of consecutive qubits. In addition, each set has a fixed overlap (e.g. of two qubits) with the set immediately before and immediately after. This very peculiar structure defines quantum convolutional codes and we can prove [13] that this implies the possibility of online encoding and the existence of an efficient error estimation algorithm.
Encoding circuit -As explained in D. Gottesman's Ph.D. thesis [14], there are various ways to realize the encoding into the code subspace. However, for convolutional codes, they are not equivalent: standard encoding circuits usually require to wait until the last 'to-beprotected' qubit has been obtained before sending the encoded state. In this section, we explain how to take advantage of the structure of the stabilizer generators to overcome this limitation and encode the qubits online. We first exhibit a map from the computational basis of the 'to-be-protected' qubits to a basis of the code subspace. As a second step, we derive the quantum circuit implementing this map in a unitary way.
More precisely, consider the following set of states: where P = i (I + M i )/ √ 2 is the projection operator onto the code subspace. Since Z i commutes with all the generators of the stabilizer group, the following equation holds for any element of the set: In practice, to encode a stream of qubits q i , we first add to it ancillary qubits in the |0 state such that the 'to-be-protected' qubit i is now at the position 5i + 1. Then, we need to implement P for these specific input states as a unitary transformation onto the whole Hilbert space. This can be done in full generality as explained in [14], and gives the encoding circuit of Fig. 1. From this simple example, it is easy to understand that the possibility of online encoding for quantum convolutional codes is a consequence of the finite extension of the support of the generators of the stabilizer group and of the encoded Pauli operators. Also note that alternative encoding methods can be found and can be relevant when considering some specific applications, but these issues are beyond the scope of this letter.
Error propagation and online decoding -Due to their very specific nature, convolutional codes propagate information contained in a given qubit to its successors (see again Fig. 1). During the decoding process (i.e. the inverse of encoding) this can actually become a problem: an error affecting a finite number of qubits before decoding can propagate through the decoding circuit and finally affect an infinite number of qubits. Such error is called catastrophic. It is worth mentioning that this issue is to the quantum domain: classical convolutional encoders might have catastrophic errors [15,16]. Fortunately, in both cases, non-catastrophic encoders exist. More precisely, given a specific encoder one can find a procedure to determine whether it has catastrophic errors or not. For classical codes this is a well known result established by Massey and Sain [17]. For the quantum domain, we can show [13] that the circuit of noncatastrophic encoders fulfills the following requirement: its gates form a finite number of layers and commute with each other inside a layer. The idea behind this theorem is simple. In general, an error affecting some qubits will propagate to all the other qubits involved in a gate with the erroneous ones. When those qubits are further used in other gates the error continues to propagate until no more gates are applied. The commutation relation together with the finiteness of the number of layers ensures that, for any finite size error, only a finite number of gates will enter in the propagation process. Thus all errors are non-catastrophic. Fig. 2 illustrates this 'pearl-necklace' structure for our example, and thus proves that our rate 1/5 quantum convolutional code is non-catastrophic.
Moreover, it can be shown that this condition implies the existence of a forward decoding scheme: there is no need to wait for the last qubit to start decoding (see Fig. 2). For non-catastrophic codes, both encoding and decoding can be done online [13].
Maximum likelihood error estimation -An error correcting code aims at protecting information sent over a noisy communication channel by letting the receiver infer which error possibly affected the information. This is the role of the error estimation algorithm. On average, the correct information is most often retrieved when the estimated error coincides with the most likely error. Thus, it is both of theoretical and practical relevance to have an efficient maximum likelihood error estimation algorithm for our quantum convolutional codes. In this section, we exhibit such algorithm. It is indeed the quantum analogue of the well-known Viterbi algorithm for classical convolutional codes. The Viterbi algorithm realizes a maximum likelihood error estimation on all memoryless channels with a complexity linear in the number of encoded bits. This explains why classical convolutional codes are so widely used for reducing the noise on communication channels.
Our algorithm for quantum convolutional codes processes the information obtained through the syndrome in order to infer the most likely error. The circuit for obtaining the syndromes follows the usual phase estimation scheme: an ancillary qubit is prepared in the |0 state; undergoes a Hadamard transform; controls the application of one of the generator M i of the stabilizer group; again undergoes a Hadamard transform; and is finally measured in the {|0 , |1 } basis. Then, the algorithm updates a list of maximum likelihood error candidates by looking at a small number of syndromes at a time, and by taking local decisions. It is preceded and followed by appropriate initialization and termination steps.
The initialization step lists all error candidates, {E 0 j } j , for the first two qubits which are compatible with the syndrome M 0 . There are exactly 8 = 4 2 /2 of them (there are 4 2 different operators with support on the first two qubits, but the constraint associated with M 0 divides this set into two equal parts). This list constitutes the input of the main loop of the algorithm. At step i, the algorithm constructs a list of some most likely error candidates, {E i j } j compatible with the syndromes M 0 to M 4i . Each candidate E i j is thus specified only on qubits 1 to 5i+2. The crucial point of the algorithm is to maintain a fixed size of this list, and hence to avoid the exponential blow up that would arise when listing all error candidates compatible with these syndromes. More precisely, E i j is a most likely candidate whose restriction on qubit 5i + 1 and 5i + 2 is prescribed by the index j running over the set of 16 possible errors affecting those two qubits. The computation of any error candidate E i+1 k is easily achieved provided {E i j } j : consider the set of all possible extensions of the error candidates E i j to qubit 5i + 3 to 5i + 7 with the prescribed error k at position 5i + 6 and 5i + 7. It is easy to check that any such element is now compatible with syndromes M 0 to M 4(i+1) . The specific candidate E i+1 k is chosen to be the most likely operator among the elements of the latter set (in case of tie, one is chosen at random). This procedure is continued until reaching M ∞ , which again selects half of the candidates. The termination of the algorithm outputs the most likely candidate among the remaining ones. This constitutes the most likely error given the value of all the syndromes for the received stream of qubits [13].
The main property used to prove this fact is related to the structure of the generators of the stabilizer group: the value of the syndromes associated to M 4i+1 to M 4i+4 depend on the syndromes M 0 to M 4i only through the error operators at position 5i+1 and 5i+2. Thus, taking a sequence of local decisions allows to construct a list of error candidates among which one will coincide with the most likely error until qubit 5i + 2 while maintaining a linear complexity of the algorithm as the number of encoded qubits increases. Note that, the error maximizing the likelihood is known when the last syndrome is measured. Hence, it is in principle necessary to wait till the end of the transmission to actually correct the estimated error. However, as for the classical Viterbi algorithm, numerical simulations show that the different candidates at a given step coincide with the most likely error except on their last few positions. Thus, in practice it is possible to estimate the error online. In addition, we want to stress, that without increasing its complexity, this algorithm can take into account all memoryless quantum channels even if the single qubit error probabilities are not constant in time. For example, one could imagine that the qubits are photons sent through an optical fiber, and that the probabilities are evaluated by sending probe photons containing no useful information. Finally, as the codes described here are the exact translation to the quantum setting of the classical convolutional codes, one can also derive suboptimal error estimation algorithms (for their classical analogues see [15,16]). Most importantly, quantum convolutional codes can be decoded iteratively and allow quantum turbo decoding [13].
Conclusion -In this letter, we presented the theory of quantum convolutional codes by an example. We gave explicitly the associated encoding and decoding circuits, as well as a low complexity maximum likelihood error estimation algorithm. We believe that such codes could be used to reduce errors for long distance quantum communications provided that we are able to perform a small and fixed number quantum gates with good fidelity. Moreover, the tools developed for quantum convolutional codes can be used to translate other families of classical codes to the quantum domain, like for instance low density parity check codes.