Recursive quantum convolutional encoders are catastrophic: A simple proof
Poulin, Tillich, and Ollivier discovered an important separation between the classical and quantum theories of convolutional coding, by proving that a quantum convolutional encoder cannot be both non-catastrophic and recursive. Non-catastrophicity is desirable so that an iterative decoding algorithm converges when decoding a quantum turbo code whose constituents are quantum convolutional codes, and recursiveness is as well so that a quantum turbo code has a minimum distance growing nearly linearly with the length of the code, respectively. Their proof of the aforementioned theorem was admittedly “rather involved,” and as such, it has been desirable since their result to find a simpler proof. In this paper, we furnish a proof that is arguably simpler. Our approach is group-theoretic—we show that the subgroup of memory states that are part of a zero physical-weight cycle of a quantum convolutional encoder is equivalent to the centralizer of its “finite-memory” subgroup (the subgroup of memory states which eventually reach the identity memory state by identity operator inputs for the information qubits and identity or Pauli- operator inputs for the ancilla qubits). After proving that this symmetry holds for any quantum convolutional encoder, it easily follows that an encoder is non-recursive if it is non-catastrophic. Our proof also illuminates why this no-go theorem does not apply to entanglement-assisted quantum convolutional encoders—the introduction of shared entanglement as a resource allows the above symmetry to be broken.
Quantum convolutional coding is an approach to quantum error correction that allows a sender to encode a stream of quantum data in an online fashion, by the repeated application of some encoding unitary . As soon as the qubits have been encoded, the sender can then transmit them over a noisy quantum channel to a receiver, whereupon the receiver can begin to decode the qubits as he receives them. An advantage of this approach is that the encoding complexity is linear in the number of qubits that are encoded, and the most clear application of these codes is in the context of quantum communication. One can also realize a quantum turbo code by serially concatenating two quantum convolutional encoders . Quantum turbo codes have linear encoding and decoding complexity, and they are known (from numerical simulations) to exhibit good performance when the noisy channel is a depolarizing channel [8, 11].
The notions of a state diagram, catastrophicity, and recursiveness are prominent in the classical theory of convolutional coding [9, 4, 6], and Poulin, Tillich, and Ollivier (PTO) were the first to provide satisfying definitions of these notions for a quantum convolutional encoder . In fact, a casual glance at the development in Ref.  might lead one to believe that there is little difference between the classical and quantum theories of convolutional coding, given that the classical definitions of state diagram, catastrophicity, and recursiveness were essentially imported and then adapted to the quantum setting.
In spite of the apparent similarities, PTO found a striking separation between the classical and quantum theories of convolutional coding: in the quantum case, encoders cannot be both non-catastrophic and recursive . Recall that in the classical case, convolutional encoders can certainly possess both properties, and in fact, one looks for encoders satisfying both when constructing classical turbo codes . Non-catastrophicity ensures that an iterative decoding algorithm for a turbo code converges, while recursiveness of one of the convolutional encoders ensures that the turbo code has a minimum distance growing nearly linearly with the number of qubits being encoded (this is true for both the classical and quantum cases [5, 8, 1]). The important theorem of PTO was then later extended to apply to quantum convolutional encoders for subsystem codes , but Ref.  also pointed out that this theorem does not apply if a sender and receiver share entangled Bell states before communication begins (in fact, the theory of entanglement-assisted quantum convolutional coding bears more similarities with the classical theory than does the “unassisted” theory of quantum convolutional coding).
The purpose of the present paper is to simplify the proof of the PTO theorem, stated as “recursive quantum convolutional encoders are catastrophic.” One might deem it unnecessary to do so given that PTO have already provided a proof, but it is often the case that if a theorem is sufficiently important, then alternate proofs can provide more insight into the theorem itself, perhaps spark new developments, or be useful for pedagogical purposes. Since this theorem gives such a strong separation between the classical and quantum theories, it clearly stands as one of the most important results in the theory of quantum convolutional coding. In the case of the PTO theorem, a quick glance over its original proof indicates that it is complicated. Indeed, Ref.  states that “the proof of Theorem 1 is rather involved,” and as such, they leave its many details to an appendix.
We now provide a brief summary of our proof of the PTO theorem for the expert
in quantum convolutional coding (this summary should become more
understandable for the non-expert after reviewing the background material in
the next section). First, it is apparently simpler to prove the
logically-equivalent contrapositive of the PTO theorem. That is, we prove the
statement “If a quantum convolutional encoder is
non-catastrophic, then it is non-recursive.” Our approach
relies heavily on the use of group theory. We define a finite-memory subgroup
, which consists of all the memory states of a quantum
convolutional encoder that eventually reach the identity memory state via a
path in the state diagram resulting from applying combinations of identity and
Pauli- operators on the ancilla qubits and identity operators on the
information qubits (we call such paths “finite standard
We structure this paper as follows. In the next section, we review the definition of a quantum convolutional code, a quantum convolutional encoder, a state diagram, catastrophicity, and recursiveness. Ref.  established these definitions, but we repeat them here for convenience and invite the expert to skip the next section. Section 3 presents our proof of the PTO theorem along the lines outlined in the previous paragraph. Section 4 provides a brief discussion to conclude this paper.
2.1 Quantum convolutional codes
We begin by recalling some standard facts, and then we review the definition of a quantum convolutional code. A Pauli sequence is a countably-infinite tensor product of Pauli matrices:
where each operator in the sequence is an element of the Pauli
Definition 1 (Quantum Convolutional Code)
A rate- quantum convolutional code admits a representation with a basic set of generators and all of their -qubit shifts:
In order to form a quantum convolutional code, these generators should commute with themselves and all of the -qubit shifts of themselves and the other generators.
Equivalently, a rate- quantum convolutional code is specified by generators , , , , where
Each entry is an -qubit Pauli operator and is the degree of generator (in general, the degrees can be different from each other). We obtain the other generators of the code by shifting the above generators to the right by multiples of qubits. (In the above, note that the entries , , …, are not required to be in the same column, but we have written them in the above way for convenience.) Note also that the generators could have an infinite degree , but in this case, they should have some periodicity. We can obtain infinite-weight generators from a finite-weight representation, for example, by multiplying the first generator by the second one and all of its shifts, and this gives a different representation of the same code.
2.2 Quantum convolutional encoders
Figure 1 depicts an example of an encoder for a quantum convolutional code. The encoder depicted there has four physical qubits for every two information qubits. The unencoded qubit stream might have the following form:
so that an ancilla qubit appears as every first and second qubit and an information qubit appears as every third and fourth qubit (generally, these information qubits can be entangled with each other and even with an inaccessible reference system, but we write them as product states for simplicity).
More generally, a convolutional encoder acts on some number of memory
qubits, ancilla qubits, and information qubits, and it produces
output physical qubits and output memory qubits to be fed into the
next round of encoding. It should transform an unencoded Pauli operator
acting on the ancilla qubit to the stabilizer
generator in (1). That is, it should be
some Clifford transformation.
where, as a visual aid, we have separated the Pauli operators acting on the memory qubits, ancilla qubits, and information qubits at the input with a vertical bar and we have done the same for those acting on the physical qubits and memory qubits at the output. The parameter is the number of memory qubits, is the number of information qubits, is the number of ancilla qubits, and we make the abbreviation . A horizontal bar separates the entries of the encoder needed to encode the first generator from the entries needed to encode the second generator. Each is a Pauli operator acting on some number of memory qubits—these operators should be consistent with the input-output commutation relations of the encoder . We stress that the above input-output relations only partially specify the encoder such that it produces a code with the stabilizer generators in (1), and there is still a fair amount of freedom remaining in the encoding. Note that it could be the case that the encoder transforms a Pauli- operator acting on an ancilla qubit to a Pauli operator with infinite weight (though, the resulting operator would have some periodicity because the encoder acts on a finite number of qubits).
2.3 State diagram
The state diagram for a quantum convolutional encoder is the most important tool for determining whether it is catastrophic or recursive . The state diagram is similar to one for a classical encoder [9, 4, 6], with an important exception for the quantum case that incorporates the fact that the logical operators of a quantum code are unique up to multiplication by the stabilizer generators. The state diagram allows us to analyze the “flow” of the logical operators through the quantum convolutional encoder.
Definition 2 (State Diagram)
The state diagram for a quantum convolutional encoder is a directed multigraph with vertices that we can think of as “memory states,” where is the number of memory qubits in the encoder. Each memory state corresponds to an -qubit Pauli operator that acts on the memory qubits. We connect two vertices and with a directed edge from to and label this edge as if the encoder takes the -qubit Pauli operator , an -qubit Pauli operator acting on the ancilla qubits, and a -qubit Pauli operator acting on the information qubits, to an -qubit Pauli operator acting on the physical qubits and an -qubit Pauli operator acting on the memory qubits:
The labels and are the respective logical and physical labels of the edge.
We now review the definition of catastrophicity from Ref. , which is based on the classical notion of catastrophicity from Refs. [9, 6]. The essential idea behind catastrophic error propagation is that an error with finite weight, after being fed through the inverse of the encoder, could propagate infinitely throughout the decoded information qubit stream without triggering syndromes corresponding to these errors. The only way that this catastrophic error propagation can occur is if there is some cycle in the state diagram where all of the edges along the cycle have physical labels equal to the identity operator, while at least one of the edges has a logical label that is not equal to the identity. If such a cycle exists, it implies that the finite-weight channel error produces an infinite-weight information qubit error without triggering syndrome bits corresponding to this error (if it did trigger syndrome bits, this cycle would not be in the state diagram), and an iterative decoding algorithm such as that presented in Ref.  is not able to detect these errors. So, we can now state the definition of a catastrophic encoder.
Definition 3 (Catastrophic Encoder)
A quantum convolutional encoder acting on memory qubits, information qubits, and ancilla qubits is catastrophic if there exists a cycle in its state diagram where all edges in the cycle have zero physical weight, but there is at least one edge in the cycle with non-zero logical weight.
Definition 4 (Path)
A path in the state diagram is a sequence of memory states , , … (with corresponding edges) such that belongs to the state diagram.
Definition 5 (Recursive encoder)
An admissable path is a path in the state diagram for which its first edge is not part of a zero physical-weight cycle. Consider any vertex belonging to a zero physical-weight loop and any admissable path beginning at this vertex that also has logical weight one. The encoder is recursive if all such paths do not contain a zero physical-weight loop.
We can gain some intuition behind the above definition by recalling the definition of a recursive classical convolutional encoder. In the classical case, an encoder is recursive if it has an infinite impulse response—that is, if it outputs an infinite-weight, periodic sequence in response to an input consisting of a single “one” followed by an infinite number of “zeros.” Definition 5 above for the quantum case ensures that the response to a single non-identity Pauli operator (one of ) at a single logical input along with the identity operator at all other logical inputs leads to a periodic output sequence of Pauli operators with infinite weight. Though, the definition above ensures that this is not only the case for the above sequence but also for one in which the ancilla qubit inputs can be chosen arbitrarily from . Thus, it is a much more stringent condition for a quantum convolutional encoder to be recursive.
3 Main result: A simple proof that recursive quantum convolutional encoders are catastrophic
We now provide a proof of the PTO theorem. Our strategy is to show that the subgroup consisting of memory states in zero physical-weight cycles is equivalent to the centralizer of the finite-memory subgroup (which we define below). After doing so, it follows rather easily that a non-catastrophic encoder must be non-recursive.
A zero physical-weight cycle has the following structure:
where , …, are arbitrary -qubit Pauli operators acting on the memory qubits, the operators act on the ancilla qubits, and the operators are arbitrary -qubit Pauli operators acting on the information qubits. A zero physical-weight cycle with non-zero logical weight is a zero physical-weight cycle such that at least one of the operators is not equal to the identity operator.
Let denote the subgroup of the Pauli group on qubits consisting of memory states that are part of a zero physical-weight cycle. That is a subgroup follows from the observation that if is part of a zero physical-weight cycle and if is part of a zero physical-weight cycle, then must be as well because we can combine the cycles of which and are a part simply by multiplying each transition of the individual cycles to get the new transitions for the zero physical-weight cycle of which is involved.
Definition 6 (Standard path)
Consider a given memory state . A standard path originating from is a path with the following structure:
where and . From the above, we can see that a standard path originating from is such that the output memory state of the row is the same as the input memory state of the row, with the ancilla operators chosen from and the input logical operators equal to the identity for every transition.
We now define two types of standard paths: finite standard paths and infinite standard paths.
Definition 7 (Finite standard path)
A finite standard path is a standard path which has “finite duration,” i.e., it ends in the identity memory state after traversing a finite number of memory states for some :
where , , …, are not equal to the identity. A finite-memory state is a memory state from which a finite standard path originates. (In (6), , , …, are finite-memory states.)
Fact 8 (Finite-memory subgroup)
The finite-memory states form a subgroup of the Pauli group on qubits, with the group property being that each element is the starting memory state for some finite standard path. That is, if and are finite-memory states, then the finite standard path originating from is constructed by multiplying the finite standard paths originating from and which individually lead to the identity memory state. Thus, this path eventually ends in the identity memory state and as such is a finite standard path. Let denote this subgroup (we will refer to it as the finite-memory subgroup).
Definition 9 (Infinite standard path)
An infinite standard path is a standard path which has infinite duration, i.e., it does not ever end in the identity memory state when the input on the ancilla qubits is chosen from the set and the input for the logical qubits is the identity. Since memory state operators act on a finite number of qubits, the input memory state of the row is the same as the output memory state of the row, for some and :
In the above, the memory states , , …, are not equal to the identity operator. Observe that different sequences , …, can lead to different cycles starting at some memory state , but that for any fixed sequence , …, we always have a cycle of this form. An infinite-memory state is a memory state which is never the starting memory state for a finite standard path.
Fact 10 (Infinite-memory set)
The set of all infinite-memory states does not form a subgroup. Indeed, let be an infinite-memory state and let be a finite-memory state. The state is then an infinite-memory state that eventually enters the same loop as . However, it is clear that the state is a finite-memory state obtained by multiplying two infinite-memory states, so that all states in the infinite-memory set need not obey the group property.
Fact 11 (Infinite-memory subgroup)
If we take the quotient of the full Pauli group acting on qubits by the finite-memory subgroup, we obtain a set of infinite-memory states that do obey the group property. That is, if and are infinite-memory states in this subgroup, then every standard path originating from is constructed by multiplying every standard path originating from and . The resulting paths will never end in the identity memory state no matter which operators in are input for the ancilla qubits. Let denote this subgroup (for simplicity, we will refer to it as the infinite-memory subgroup, and our convention is that the identity memory state is part of this subgroup). Thus, all memory states in this subgroup are infinite-memory and we obtain only infinite-memory states when multiplying them together.
One can easily construct a generating set for the infinite-memory subgroup explicitly if a generating set for the finite-memory subgroup is available. Indeed, we would just need to find independent generators such that constitutes a generating set for the Pauli group on the memory qubits. The generating set then generates the infinite-memory subgroup mentioned above.
Observe that the finite-memory subgroup and the infinite-memory subgroup are independent subgroups, and together they constitute the full Pauli group acting on qubits.
The memory states in a zero physical weight cycle commute with each element of the finite-memory subgroup .
Proof. The proof of this lemma is similar to the proof of Theorem 7 in Ref. . For completeness, we repeat it here. Consider that the RHS of the last row of (6) commutes with the RHS of any of the rows of (4). This then implies that the LHS of the last row of (6) commutes with the LHS of any of the rows of (4). Since the operators already commute, this implies that in (4) commute with in (6). This in turn implies that the RHS of the second-to-last row of (6) commutes with the RHS of any row of (4), and furthermore, that the LHS of the second-to-last row of (6) commutes with the LHS of any row of (4). So we have that in (4) commutes with in (6). Continuing this argument inductively, we can conclude the statement of the lemma.
Let denote the subgroup consisting of memory states that commute with each element of the finite-memory subgroup (so that is the centralizer of ). The above lemma states that the zero physical-weight cycle subgroup is a subset of the centralizer of the finite-memory subgroup: . The rest of our proof is dedicated to proving the other containment: , implying that the zero physical-weight cycle subgroup is equivalent to the centralizer of the finite-memory subgroup: . Having this will then allow us to easily prove that all non-catastrophic encoders are non-recursive.
Now consider the following transformation corresponding to the response of the encoder to a Pauli- operator on one of the ancilla qubits:
where . The encoder acts on a finite number of qubits, so it must either end in the identity memory state or cycle after following a path from in which the identity operator is always input for both the ancilla and information qubits. Thus, we either have
in which case the input leads to a finite standard path, or we have
so that the encoder enters some cycle. In this latter case, the following input sequence drives the encoder back to the identity memory state:
So the memory states resulting from the input are always part of the finite-memory subgroup , and based on Lemma 12, these memory states commute with the memory states in any zero-physical-weight cycle.
Suppose that a memory state (that is, it commutes with each element of ). Then there is a unique memory state , an , and an such that the encoder transforms as follows:
Proof. First, the transition in (9) is part of the encoder because we can always act with the inverse of the encoder on , producing some unique as the input operators. Then, by assumption, , implying that the RHS of (9) commutes with the RHS of (8) for all because . Thus, the LHS of (9) should commute with the LHS of (8) for all . This implies that . Also, commutes with all states in () for the same reason that the zero physical weight cycles from Lemma 12 commute with the finite-memory subgroup . This is due to the particular form in (9), the need for input-output commutativity consistency between (9) and (6), and the fact that .
Suppose that a memory state (that is, it commutes with each element of ). Then there is a unique memory state , an , and an such that the encoder transforms as follows:
Proof. Let be a generating set for the finite-memory subgroup and let be a generating set for the infinite-memory subgroup . For every , there exists a and such that
Furthermore, the operators form a generating set for . If it were not so (that these operators were not independent), we would be able to take certain multiplicative combinations of the operators at the input and construct a path to the identity memory state, contradicting the fact that the operators form a generating set for elements of the infinite-memory subgroup . Thus, is a generating set for as well.
Now, we fix to be the unique Pauli operator on qubits that commutes with each element of and such that its commutation relation with each in is the same as the commutation relation of with the corresponding in (the correspondence between and being set by (11)). The uniqueness of follows from the fact that specifying the commutation relations of an -qubit Pauli operator with each element of a generating set for the Pauli group on qubits completely specifies that operator up to an irrelevant global phase. Additionally, the above choice for implies that .
To obtain the conclusion of the lemma, we consider applying the inverse of the encoder to . By Lemma 13, there exists an , an , and an such that
But this must be equal to by construction—the encoder preserves the commutation relations between the RHSs of (11-12) and the LHSs of (11-12) and we already know that . As we stated above, these commutation relations completely specify and we can thus conclude that . This concludes the proof of the lemma since we have constructed a unique , , and satisfying (10) for all .
The above proof works just as well by replacing all the transitions in (11) with the following ones:
for some fixed .
Suppose that a memory state . Then is a part of a zero physical-weight cycle, such that all memory states of this cycle are in .
Proof. From Lemma 14, we know that there is a unique memory state , an , and an such that
This is also the case for . That is, there exists a unique memory state , an , and an such that
This process cannot go on indefinitely (that of finding a new that has not yet already appeared, for a given ). The centralizer of the finite-memory subgroup has a finite number of elements, and at some point, the transition is guaranteed to return back to . Also, note that these zero physical-weight transitions cannot go back to any of through before going back to —this would contradict Lemma 13. Thus, is part of a zero physical-weight cycle of the following form:
Theorem 18 (Poulin, Tillich, Ollivier )
A non-catastrophic encoder is non-recursive.
Proof. Consider the following transition, resulting from a weight-one logical input:
For a non-catastrophic encoder, all of the edges in a zero physical-weight cycle have zero logical weight, so that the LHS of (14) commutes with the LHS of the transitions in these zero physical-weight cycles. Thus, the RHSs commute as well. Since zero physical-weight cycles have the identity operator acting on physical qubits, the above memory state commutes with all memory states of zero-physical weight cycles, so that . According to Corollary 17, the memory state , and according to Fact 8, there is a standard path from to the identity memory state, implying that the encoder is non-recursive.
Our proof of the above theorem illustrates a particular property of any non-catastrophic quantum convolutional encoder. Transitions of the following form
for all and lead to a memory state , from which there is a standard path to the identity memory state.
We have provided a proof of the statement “recursive quantum convolutional encoders are catastrophic” that is arguably simpler than the one originally furnished by Poulin, Tillich, and Olliver in Ref. . Our approach was to show that the subgroup of memory states that are part of zero physical-weight cycles is equivalent to the centralizer of the finite-memory subgroup. From there, it was straightforward to prove the PTO theorem.
The proof given here also provides insight into why entanglement-assisted quantum convolutional encoders can circumvent this no-go theorem. In particular, an examination of the example from Figure 4 of Ref.  reveals that its zero physical-weight cycle subgroup consists of only the identity memory state, so that its centralizer contains all memory states. Yet, the finite-memory subgroup for this example is empty. Thus, the symmetry between these two subgroups is broken by the introduction of entanglement, and the no-go theorem no longer applies.
We acknowledge Jean-Pierre Tillich for suggesting to us at QIP 2011 in Singapore that it would be worthwhile to pursue a simpler proof of Theorem 18. We also acknowledge useful discussions with Min-Hsiu Hsieh on this topic, and we are grateful for the suggestions of the anonymous referee. MMW acknowledges support from the Centre de Recherches Mathématiques at the University of Montreal.
- This formulation of the finite-memory subgroup is different from that in Ref. , and it is a further step that is helpful in simplifying the proof of the PTO theorem.
- In our work, to be precise, we are dealing with the quotient of the Pauli group by its center, so that global phases are irrelevant. For simplicity, in this paper we refer to the quotient of the Pauli group by its center as “the Pauli group.”
- A Clifford transformation is a unitary operator that preserves the Pauli group under unitary conjugation.
- Mamdouh Abbara and Jean-Pierre Tillich. The minimum distance of classical and quantum turbo-codes. September 2011. arXiv:1109.0215.
- S. Benedetto, D. Divsalar, G. Montorsi, and F. Pollara. Serial concatenation of interleaved codes: performance analysis, design, and iterative decoding. IEEE Transactions on Information Theory, 44(3):909–926, May 1998.
- Monireh Houshmand, Saied Hosseini-Khayat, and Mark M. Wilde. Minimal-memory, non-catastrophic, polynomial-depth quantum convolutional encoders. Accepted into the IEEE Transactions on Information Theory, 2012. arXiv:1105.0649.
- Rolf Johannesson and Kamil Sh. Zigangirov. Fundamentals of Convolutional Coding. Wiley-IEEE Press, 1999.
- Nabil Kahale and Rüdiger Urbanke. On the minimum distance of parallel and serially concatenated codes. In Proceedings of the International Symposium on Information Theory, page 31, Cambridge, Massachussetts, USA, August 1998.
- Robert J. McEliece. The Theory of Information and Coding. Cambridge University Press, 2002.
- Harold Ollivier and Jean-Pierre Tillich. Description of a quantum convolutional code. Physical Review Letters, 91(17):177902, October 2003.
- David Poulin, Jean-Pierre Tillich, and Harold Ollivier. Quantum serial turbo-codes. IEEE Transactions on Information Theory, 55(6):2776–2798, June 2009.
- Andrew J. Viterbi. Convolutional codes and their performance in communication systems. IEEE Transactions on Communication Technology, 19(5):751–772, October 1971.
- Mark M. Wilde and Min-Hsiu Hsieh. Entanglement boosts quantum turbo codes. Proceedings of the 2011 IEEE International Symposium on Information Theory, pages 445–449, August 2011. Saint-Petersburg, Russia.
- Mark M. Wilde, Min-Hsiu Hsieh, and Zunaira Babar. Entanglement-assisted quantum turbo codes. May 2013. arXiv:1010.1256v3.