Entanglement-assisted quantum convolutional coding

# Entanglement-Assisted Quantum Convolutional Coding

## Abstract

We show how to protect a stream of quantum information from decoherence induced by a noisy quantum communication channel. We exploit preshared entanglement and a convolutional coding structure to develop a theory of entanglement-assisted quantum convolutional coding. Our construction produces a Calderbank-Shor-Steane (CSS) entanglement-assisted quantum convolutional code from two arbitrary classical binary convolutional codes. The rate and error-correcting properties of the classical convolutional codes directly determine the corresponding properties of the resulting entanglement-assisted quantum convolutional code. We explain how to encode our CSS entanglement-assisted quantum convolutional codes starting from a stream of information qubits, ancilla qubits, and shared entangled bits.

quantum convolutional codes, entanglement-assisted quantum convolutional codes, quantum information theory, entanglement-assisted quantum codes

## I Introduction

Quantum error correction theory (1); (2); (3); (4); (5); (6) stands as the pivotal theoretical tool that will make reliable quantum computing and quantum communication possible. Any future quantum information processing device will operate faithfully only if it employs an error correction scheme. This scheme can be an active scheme (4), a passive scheme (7); (8); (9), or a combination of both techniques (10); (11); (12); (13); (14).

Mermin proclaims it a “miracle” that quantum error correction is even possible (15). Various obstacles such as the no-cloning theorem (16), measurement destroying a quantum state, and continuous quantum errors seem to pose an insurmountable barrier to a protocol for quantum error correction. Despite these obstacles, Shor demonstrated the first quantum error-correcting code that reduces the negative effects of decoherence on a quantum bit (1). Shor’s code overcame all of the above difficulties and established the basic principles for constructing a general theory of quantum error correction (4); (5); (6).

Gottesman formalized the theory of quantum block coding by establishing the stabilizer formalism (4). The stabilizer formalism allows one to import self-orthogonal classical block codes for use in quantum error correction (6). This technique has the benefit of exploiting the large body of research on classical coding theory (17) for use in quantum error correction, but the self-orthogonality constraint limits the classical block codes that we can import.

Bowen was the first to extend the stabilizer formalism by providing an example of a code that exploits entanglement shared between a sender and a receiver (18). The underlying assumption of Bowen’s code is that the sender and receiver share a set of noiseless ebits (entangled qubits) before quantum communication begins. Many quantum protocols such as teleportation (19) and superdense coding (20) are “entanglement-assisted” protocols because they assume that noiseless ebits are available.

Brun, Devetak, and Hsieh generalized Bowen’s example by constructing a theory of stabilizer codes that employs ancilla qubits and shared ebits for encoding a quantum error-correcting code (21); (22). The so-called entanglement-assisted stabilizer formalism subsumes the stabilizer formalism as the theory of active quantum error correction.

The major benefit of the entanglement-assisted stabilizer formalism is that we can construct an entanglement-assisted quantum code from two arbitrary classical binary block codes or from an arbitrary classical quaternary block code. The rates and error-correcting properties of the classical codes translate to the resulting quantum codes. The entanglement-assisted stabilizer formalism may be able to reduce the problem of finding high-performance quantum codes approaching the quantum capacity (23); (24); (25); (26); (27) to the problem of finding good classical linear codes approaching the classical capacity (28).

Another extension of the theory of quantum error correction protects a potentially-infinite stream of quantum information against the corruption induced by a noisy quantum communication channel (29); (30); (31); (32); (33); (34); (35). These quantum convolutional codes possess several advantages over quantum block codes. A quantum convolutional code typically has lower encoding and decoding complexity and superior code rate when compared to a block code that protects the same number of information qubits (35).

Forney et al. have determined a method for importing an arbitrary classical self-orthogonal quaternary code for use as a quantum convolutional code (34); (35). The technique is similar to that for importing a classical block code as a quantum block code (6). One limitation of this technique is that the self-orthogonality constraint is more restrictive in the convolutional setting. Each generator for the quantum convolutional code must commute not only with the other generators, but it must commute also with any arbitrary shift of itself and any arbitrary shift of the other generators. Forney et al. performed specialized searches to determine classical quaternary codes that satisfy the restrictive self-orthogonality constraint (35).

In this paper, we develop a theory of entanglement-assisted quantum convolutional coding for a broad class of codes. Our major result is that we can produce an entanglement-assisted quantum convolutional code from two arbitrary classical binary convolutional codes. The resulting quantum convolutional codes admit a Calderbank-Shor-Steane (CSS) structure (3); (2); (36). The rates and error-correcting properties of the two binary classical convolutional codes directly determine the corresponding properties of the entanglement-assisted quantum convolutional code.

Our techniques for encoding and decoding are also an expansion of previous techniques from quantum convolutional coding theory. Previous techniques for encoding and decoding include finite-depth operations only. A finite-depth operation propagates errors to a finite number of neighboring qubits in the qubit stream. We introduce an infinite-depth operation to the set of shift-invariant Clifford operations and explain it in detail in Section VI. We must be delicate when using infinite-depth operations because they can propagate errors to an infinite number of neighboring qubits in the qubit stream. We explain our assumptions in detail in Section VII for including infinite-depth operations in our entanglement-assisted quantum convolutional codes. An infinite-depth operation gives more flexibility when designing encoding circuits—similar to the way in which an infinite-impulse response filter gives more flexibility in the design of classical convolutional circuits. It also is the key operation enabling us to import arbitrary classical convolutional codes for entanglement-assisted quantum coding.

Our CSS entanglement-assisted quantum convolutional codes divide into two classes based on certain properties of the classical codes from which we produce them. These properties of the classical codes determine the structure of the encoding and decoding circuit for the code, and the structure of the encoding and decoding circuit in turn determines the class of the entanglement-assisted quantum convolutional code.

1. Codes in the first class admit both a finite-depth encoding and decoding circuit.

2. Codes in the second class have an encoding circuit that employs both finite-depth and infinite-depth operations. Their decoding circuits have finite-depth operations only.

We structure our work as follows. Section II reviews the stabilizer formalism for quantum block codes, entanglement-assisted quantum codes, and convolutional stabilizer codes. We review the important isomorphism that allows us to work with matrices of binary polynomials rather than infinite tensor products of Pauli matrices. Section III reviews finite-depth Clifford operations for use in encoding and decoding (31); (32); (33). We outline the operation of an entanglement-assisted quantum convolutional code and present our main theorem in Section IV. This theorem shows how to produce a CSS entanglement-assisted quantum convolutional code from two arbitrary classical binary convolutional codes. The theorem gives the rate and error-correcting properties of a CSS entanglement-assisted quantum convolutional code as a function of the parameters of the classical convolutional codes. Section V completes the proof of the theorem for our first class of entanglement-assisted quantum convolutional codes. In Section VI, we introduce an infinite-depth encoding operation to the set of shift-invariant Clifford operations and discuss its effect on both the stabilizer and the logical operators for the information qubits. Section VII completes the proof of our theorem for the second class of entanglement-assisted quantum convolutional codes. We discuss the implications of the assumptions for the different classes of entanglement-assisted quantum convolutional codes while developing the constructions. Our hope is that our theory will produce high-performance quantum convolutional codes by importing high-performance classical convolutional codes.

## Ii Review of the Stabilizer Formalism

The stabilizer formalism is a mathematical framework for quantum error correction (37); (4). This framework has many similarities with classical coding theory, and it is even possible to import a classical code for use in quantum error correction by employing the CSS construction (3); (2); (36). We briefly review the stabilizer theory for quantum block codes, entanglement-assisted quantum block codes, and quantum convolutional codes (see Refs. (35); (38) for a more detailed review).

### ii.1 Stabilizer Formalism for Quantum Block Codes

The following four matrices

 I≡[1001], X≡[0110], Y≡[0−ii0], Z≡[100−1],

in the Pauli group  are the most important in formulating a quantum error-correcting code. Two crucial properties of these matrices are useful: each matrix in has eigenvalues equal to or , and any two matrices in either commute or anticommute. Matrices in act on a two-dimensional complex vector, or equivalently, a single qubit.

In general, a quantum error-correcting code uses physical qubits to protect a smaller set of information qubits against decoherence or quantum noise. An -qubit quantum error-correcting code employs elements of the Pauli group . The Pauli group consists of -fold tensor products of Pauli matrices:

 Πn={eiϕA1⊗⋯⊗An:∀j∈{1,…,n},Aj∈Π,  ϕ∈{0,π/2,π,3π/2}}. (1)

We liberally omit the tensor product symbol in what follows so that . The above two crucial properties for the single-qubit Pauli group still hold for the Pauli group (up to an irrelevant phase for the eigenvalue property). Matrices in act on a -dimensional complex vector, or equivalently, an -qubit quantum register.

We can phrase the theory of quantum error correction in purely mathematical terms using elements of . Consider a matrix that is not equal to . Matrix then has two eigenspaces each of size . We can identify one eigenspace with the eigenvalue and the other eigenspace with eigenvalue . Consider a matrix different from that commutes with . Matrix also has two eigenspaces each of size and identified similarly by its eigenvalues . Both and have simultaneous eigenspaces because they commute. These matrices together have four different eigenspaces, each of size and identified by the eigenvalues of and respectively. We can continue this process of adding more commuting and independent matrices to a set . The matrices in are independent in the sense that no matrix in is a product of two or more other matrices in . Adding more matrices from  to continues to divide the eigenspaces of matrices in . In general, suppose consists of independent and commuting matrices , …, . These matrices then have different eigenspaces each of size and identified by the eigenvalues , …,  of , …, respectively. Consider that the Hilbert space of qubits has size . A dimension count immediately suggests that we can encode qubits into one of the eigenspaces of . We typically encode these qubits into the simultaneous -eigenspace of , …, . This eigenspace is the codespace. An quantum error-correcting code encodes information qubits into the simultaneous -eigenspace of matrices , …, . The rate of an code is the ratio of information qubits to physical qubits: .

The operation of an quantum error-correcting code consists of four steps. Figure 1 highlights these steps. First, a unitary operation encodes qubits and ancilla qubits into the simultaneous -eigenspace of the matrices , …, . The sender transmits the encoded qubits by using the noisy quantum communication channel times. The receiver performs quantum measurements of the matrices , …, . These measurements learn only about errors that may occur and do not disturb the encoded quantum information. Each measurement gives a bit result equal to or , and the result of all the measurements is to project the -qubit quantum register into one of the different eigenspaces of , …, . Suppose that no error occurs. Then the measurements project the qubits into the simultaneous -eigenspace and return a bit vector consisting of ones. Now suppose that a quantum error in an error set occurs. The error takes the encoded quantum state out of the codespace and into one of the other orthogonal eigenspaces. The measurements can detect that an error has occurred because the result of the measurements is a bit vector differing from the all ones vector. The receiver may be able to identify uniquely which error has occurred if it satisfies the following quantum error correction conditions:

 ∀Ea,Eb∈E  ∃ gi∈S:{gi,E†aEb}=0 \ or \ E†aEb∈S.

The first condition states that errors are detectable if they anticommute with one of the generators in , and the second condition states that errors have no effect on the encoded state if they are in . If the receiver can identify which error occurs, he can then apply unitary operation  that is the inverse of the error. He finally performs a decoding unitary that decodes the information qubits.

We comment briefly on the encoding operation . The encoding operation is a special type of unitary matrix called a Clifford operation. A Clifford operation  is one that preserves elements of the Pauli group under conjugation: . The CNOT gate, the Hadamard gate , and the phase gate suffice to implement any unitary matrix in the Clifford group (4). A quantum code with the CSS structure needs only the CNOT and Hadamard gates for encoding and decoding. The matrix for the CNOT gate acting on two qubits is

 CNOT=⎡⎢ ⎢ ⎢⎣1000010000010010⎤⎥ ⎥ ⎥⎦, (2)

the matrix for the Hadamard gate acting on a single qubit is

 H=1√2[111−1], (3)

and the matrix for the phase gate acting on a single qubit is

 P=[100i]. (4)

For the CNOT gate, the first qubit is the “control” qubit and the second qubit is the “target” qubit. The standard basis for elements of the two-qubit Pauli group is as follows

 ZIIZXIIX, (5)

because any element of is a product of the above four matrices up to an irrelevant phase. The standard basis for is and for the same reasons. The CNOT gate transforms the standard basis of under conjugation as follows

 ZIIZXIIX→ZIZZXXIX, (6)

where the first qubit is the control and the second qubit is the target. The Hadamard gate transforms the standard basis of under conjugation as follows:

 ZX→XZ, (7)

and the phase gate transforms the standard basis as follows:

 ZX→ZY. (8)

Appendix of Ref. (38) details an algorithm that determines an encoding circuit consisting of CNOT, , and gates for any stabilizer code or any entanglement-assisted stabilizer code (we review entanglement-assisted codes in the next section).

Another aspect of the theory of quantum error correction is later useful for our purposes in quantum convolutional coding. This aspect concerns the information qubits and the operators that change them. Consider that the initial unencoded state of a quantum error-correcting code is a simultaneous +1-eigenstate of the matrices where has a matrix operating on qubit and the identity on all other qubits. Therefore, the matrices constitute a stabilizer for the unencoded state. The initial unencoded logical operators for the information qubits are . The encoding operation rotates the unencoded stabilizer matrices and the unencoded logical operators to the encoded stabilizer , …, and the encoded logical operators respectively. The encoded matrices are respectively equivalent to the matrices , …, in the above discussion. The encoded operators obey the same commutation relations as their unencoded counterparts. We would violate the uncertainty principle if this invariance does not hold. Therefore, each of the encoded logical operators commutes with elements of the stabilizer . Let  denote an arbitrary logical operator from the above set and let denote an arbitrary element of the stabilizer . The operator (or equivalently ) is an equivalent logical operator because and have the same effect on an encoded state :

 Missing or unrecognized delimiter for \right (9)

We make extensive use of the above fact in our work.

The logical operators also provide a useful way to characterize the information qubits. Gottesman showed that the logical operators for the information qubits provide a straightforward way to characterize the information qubits as they progress through a quantum circuit (4). As an example of this technique, he develops quantum teleportation in the stabilizer formalism. The logical operators at the beginning of the protocol are and and become and at the end of the protocol. The quantum information in qubit one teleports to qubit three because the logical operators act on only qubit three at the end of the protocol. We use the same idea throughout this paper to determine if our decoding circuits have truly decoded the information qubits.

It is possible to produce a stabilizer code from two classical binary block codes by employing the CSS construction. The elements of the stabilizer group of a CSS stabilizer code commute if and only if the codewords of one classical code are orthogonal to the codewords of the other classical code with respect to the binary inner product. The codes that we can import must satisfy this condition because the commuting condition is essential in formulating a quantum code. The entanglement-assisted stabilizer formalism finds a clever way around this restriction by exploiting entanglement shared between sender and receiver.

### ii.2 Entanglement-Assisted Stabilizer Formalism for Quantum Block Codes

The entanglement-assisted stabilizer formalism is a significant extension of the standard stabilizer formalism that incorporates shared entanglement as a resource for encoding (21); (22). Several references provide a review of this technique and generalizations of the basic theory to block (39) and convolutional (38) entanglement distillation protocols, continuous-variable codes (40), and entanglement-assisted operator codes for discrete-variable (13); (14) and continuous-variable systems (41).

An entanglement-assisted code employs ebits or Bell states in addition to ancilla qubits for quantum redundancy. We express the state  of an ebit shared between a sender Alice and a receiver Bob as follows:

 ∣∣Φ+⟩≡|00⟩AB+|11⟩AB√2. (10)

The advantage of the entanglement-assisted stabilizer formalism is that it allows us to exploit the error-correcting properties of an arbitrary set of Pauli matrices. They do not necessarily have to form a commuting set. In particular, this construction allows us to produce a quantum block code from two arbitrary classical binary block codes by employing the CSS construction. Two high-performance classical block codes lead to a high-performance entanglement-assisted quantum code. The entanglement-assisted method allows us to exploit the full error-correcting power of classical coding theory.

An  entanglement-assisted code uses ebits and ancilla qubits to encode information qubits. It operates as follows. The sender and receiver share ebits before quantum communication begins. The sender encodes her information qubits with the help of ancilla qubits and her half of the ebits. She performs an encoding operation  on her qubits and sends them over a noisy quantum communication channel. The noisy channel affects these qubits only and does not affect the receiver’s half of the ebits. The receiver combines his half of the ebits with those he receives from the noisy quantum channel. He performs measurements on all qubits to diagnose an error that may occur on the qubits. He learns which error occurs and performs a recovery operation that eliminates the error. Figure 2 illustrates the operation of an entanglement-assisted stabilizer code.

Suppose we have an arbitrary set of Pauli matrices in whose error-correcting properties we would like to exploit. We do not necessarily know beforehand how many ebits we require for the Pauli matrices to form a commuting set, and we would like a method to determine the minimum number of ebits. Several methods exist (21); (22); (13); (14); (38), but the algorithm in the Appendix of Ref. (38) determines the minimum number of ebits required for the code, the encoding and decoding circuit for the code, and the measurements the receiver performs to diagnose errors. It essentially “kills three birds with one stone.” The algorithms we employ in this work are similar to the algorithm in Ref. (38), but they are quite a bit more complicated because of the convolutional nature of our codes.

#### Rate of an Entanglement-Assisted Quantum Code

We can interpret the rate of an entanglement-assisted quantum convolutional code in three different ways (22); (21); (38). Suppose that an entanglement-assisted quantum code encodes qubits in qubits with the help of ebits.

1. The “entanglement-assisted” rate assumes that entanglement shared between sender and receiver is free. Bennett et al. make this assumption when deriving the entanglement-assisted capacity of a quantum channel for sending quantum information (26); (27). The entanglement-assisted rate for the above example is .

2. The “trade-off’ rate assumes that entanglement is not free and a rate pair determines performance. The first number in the pair is the number of noiseless qubits generated per channel use, and the second number in the pair is the number of ebits consumed per channel use. The rate pair for the above example is . Quantum information theorists have computed asymptotic trade-off curves that bound the rate region in which achievable rate pairs lie (42). Brun et al.’s construction for an entanglement-assisted quantum block code minimizes the number of ebits given a fixed number and of information qubits and encoded qubits respectively (21); (22).

3. The “catalytic rate” assumes that bits of entanglement are built up at the expense of transmitted qubits (21); (22). A noiseless quantum channel or the encoded use of noisy quantum channel are two different ways to build up entanglement between a sender and receiver. The catalytic rate for the above code is .

Which interpretation is most reasonable depends on the context in which we use the code. In any case, the parameters , , and ultimately govern performance, regardless of which definition of the rate we use to interpret that performance.

### ii.3 Stabilizer Formalism for Quantum Convolutional Codes

We review the theory of convolutional stabilizer codes by considering a set of Pauli matrices that stabilize a stream of encoded qubits. We follow with the most important part of this review—the isomorphism from the set of Pauli sequences to the module over the ring of binary polynomials (30); (31); (35). We name it the Pauli-to-binary (P2B) isomorphism. The P2B isomorphism is important because it is easier to perform manipulations with vectors of binary polynomials than with Pauli sequences.

We review the notation and basic definitions first. A Pauli sequence  is a countably infinite tensor product of Pauli matrices :

 A=∞⨂i=0 Ai.

The weight of a Pauli sequence is the number of Pauli matrices in the countably-infinite tensor product that are not equal to the identity matrix. A Pauli sequence has finite support if its weight is finite. Let denote the set of all Pauli sequences and let denote the set of Pauli sequences with finite support.

###### Definition 1.

A rate- quantum convolutional code consists of a basic set  of generators and all of their -qubit shifts (29); (30); (35). The generators in commute with each other and with all of their -qubit shifts. The parameters and satisfy and the basic set is as follows:

 G0={Gi∈F(ΠZ+):1≤i≤n−k}.

A frame of the code consists of qubits.

The operation of a rate- quantum convolutional code begins with the sender encoding a stream of information qubits. Figure 3 of Ref. (38) illustrates the basic operation of a quantum convolutional code. The sender encodes ancilla qubits and information qubits per frame (33); (31) and transmits the encoded qubits over a noisy quantum channel. The above stabilizer  and all of its shifts act like a parity check matrix for the quantum convolutional code. The receiver measures the generators in the stabilizer to determine an error syndrome. It is important that the generators in have finite weight so that the receiver can perform the measurements and produce an error syndrome. It is also important that the generators have a block-band form so that the receiver can perform the measurements online as the noisy encoded qubits arrive. The receiver processes the error syndrome with a method such as the Viterbi algorithm (43) or any other decoding algorithm (44) to determine the most likely error for each frame of quantum data. The receiver performs a unitary that reverses the errors. He finally processes the encoded qubits with a decoding circuit to recover the original stream of information qubits.

#### The P2B Isomorphism

We now review the P2B isomorphism from the set of phase-free Pauli sequences to the module over the ring of binary polynomials (30); (35); (38). We illustrate it by example (see Ref. (38) for a more rigorous development.)

Suppose the following two basic generators specify a rate-1/3 quantum convolutional code (34); (35):

 ⋯∣∣∣IIIIII∣∣∣XXXZZZ∣∣∣XZYZYX∣∣∣IIIIII∣∣∣⋯ (11)

The vertical bars indicate that we shift by multiples of three to obtain the other generators in the quantum convolutional code. Observe that the above two generators commute with all of their three-qubit shifts.

The P2B isomorphism is a mapping from the above stabilizer generators to a matrix whose entries are binary polynomials. The left side of the matrix is the “Z” matrix and the right side of the matrix is the “X” matrix. We consider the entries in the first frame of the stabilizer generators in (11) for now and map these entries to a matrix with binary entries. The first frame of the first generator in (11) has “X” entries only and the first frame of the second generator in (11) has “Z” entries only. The binary matrix corresponding to the entries in the first frame is as follows:

 H0=[000111∣∣∣111000].

The vertical bar now indicates the separation of the “Z” matrix on the left and the “X” matrix on the right. A “Y” entry maps to a “1” in both the “Z” and “X” matrix. Let us consider the entries in the second frame of (11). They map to the following binary matrix:

 H1=[011110∣∣∣101011].

We form a matrix of binary polynomials by incorporating the delay transform or -transform. The following binary polynomial matrix fully specifies the quantum convolutional code:

 H(D) =H0+H1⋅D =[0DD1+D1+D1∣∣∣1+D11+D0DD].

The above description of a quantum convolutional code with a binary polynomial matrix is powerful because it allows us to perform manipulations with finite polynomials rather than with countably-infinite sequences of Pauli matrices (classical convolutional coding theory exploits the same idea (44)). The first and second rows of capture all of the information about the first and second generators in (11) and all of their three-qubit shifts. We obtain the -shift of either of the above generators by multiplying the corresponding row in  by .

#### The Shifted Symplectic Product

The shifted symplectic product provides a way to determine the commutative properties of any convolutional stabilizer code (30); (38) (See Ref. (38) for a detailed discussion of the shifted symplectic product with examples). Let and denote the first and second respective rows of the “Z” matrix of . Let and be the first and second respective rows of the “X” matrix of . Let

 h1(D) =(z1(D)|x1(D)), h2(D) =(z2(D)|x2(D)),

denote the first and second respective rows of . The vectors and specify the first and second respective generators in (11). We define the shifted symplectic product of and as follows:

 (h1⊙h2)(D)=z1(D−1)⋅x2(D)+x1(D−1)⋅z2(D),

where denotes the binary inner product and addition is binary.

The shifted symplectic product vanishes in the above case. The shifted symplectic products and also vanish. The shifted symplectic product between two vectors of binary polynomials vanishes if and only if their corresponding Pauli sequences commute (30); (38). Time reversal (substituting for ) ensures that the shifted symplectic product checks commutativity for every shift of the two Pauli sequences being compared. The cases where the shifted symplectic product does not vanish (where the two Pauli sequences anticommute for one or more shifts) are important for constructing entanglement-assisted quantum convolutional codes.

#### Row and Column Operations

We can perform row operations on binary polynomial matrices for quantum convolutional codes. A row operation is merely a “mental” operation that has no effect on the states in the codespace or on the error-correcting properties of the code. We have three types of row operations:

1. An elementary row operation multiplies a row times an arbitrary binary polynomial and adds the result to another row. This additive invariance holds for any code that admits a description within the stabilizer formalism. Additive codes are invariant under multiplication of the stabilizer generators in the “Pauli picture” or under row addition in the “binary-polynomial picture.”

2. Another type of row operation is to multiply a row by an arbitrary power of . Ollivier and Tillich discuss such row operations as “multiplication of a line by ” and use them to find encoding operations for their quantum convolutional codes (30). Grassl and Rötteler use this type of operation to find a subcode of a given quantum convolutional code with an equivalent asymptotic rate and equivalent error-correcting properties (31). We use this type of row operation in each of our three classes of entanglement-assisted quantum convolutional codes.

3. We also employ row operations that multiply a row by an arbitrary polynomial (not necessarily a power of ). We only use these operations when the receiver performs a measurement to diagnose an error. This type of row operation occurs when we have generators with infinite weight that we would like to reduce to finite weight so that the receiver can perform measurements in an online fashion as qubits arrive from the noisy channel. We use this type of row operation in our second and third classes of entanglement-assisted quantum convolutional codes.

A row operation does not change the shifted symplectic product when all generators commute. A row operation does change the shifted symplectic product of a set of generators that do not commute. It is a convenient tool for constructing our entanglement-assisted quantum convolutional codes.

We can also perform column operations on binary polynomial matrices for quantum convolutional codes. Column operations change the error-correcting properties of the code and are important for realizing a periodic encoding circuit for the code. We have two types of column operations:

1. An elementary column operation multiplies one column by an arbitrary binary polynomial and adds the result to another column. We implement elementary column operations with gates from the shift-invariant Clifford group (33); (31).

2. Another column operation is to multiply column  in both the “X” and “Z” matrix by where. We perform this operation by delaying or advancing the processing of qubit  by frames relative to the original frame.

A column operation implemented on the “X” side of the binary polynomial matrix has a corresponding effect on the “Z” side of the binary polynomial matrix. This corresponding effect is a manifestation of the Heisenberg uncertainty principle because commutation relations remain invariant with respect to the action of quantum gates. The shifted symplectic product is therefore invariant with respect to column operations from the shift-invariant Clifford group. We describe possible column operations for implementing encoding circuits in the next section.

## Iii Finite-Depth Clifford Operations

One of the main advantages of a quantum convolutional code is that its encoding circuit has a periodic form. We can encode a stream of quantum information with the same physical routines or devices and therefore reduce encoding and decoding complexity.

Ollivier and Tillich were the first to discuss encoding circuits for quantum convolutional codes (29); (30). They provided a set of necessary and sufficient conditions to determine when an encoding circuit is noncatastrophic. A noncatastrophic encoding circuit does not propagate uncorrected errors infinitely through the decoded information qubit stream. Classical convolutional coding theory has a well developed theory of noncatastrophic encoding circuits (44).

Grassl and Rötteler later showed that Ollivier and Tillich’s conditions for a circuit to be noncatastrophic are too restrictive (31); (32); (33). They found subcodes of quantum convolutional codes that admit noncatastrophic encoders. The noncatastrophic encoders are a sequence of Clifford circuits with finite depth. They developed a formalism for encapsulating the periodic structure of an encoding circuit by decomposing the encoding circuit as a set of elementary column operations. Their decoding circuits are exact inverses of their encoding circuits because their decoding circuits perform the encoding operations in reverse order.

###### Definition 2.

A finite-depth operation transforms every finite-weight stabilizer generator to one with finite weight.

We review the finite-depth operations in the shift-invariant Clifford group (31); (32); (33). The shift-invariant Clifford group is an extension of the Clifford group operations mentioned in Section II.1. We describe how finite-depth operations in the shift-invariant Clifford group affect the binary polynomial matrix for a code. Each of the following operations acts on every frame of a quantum convolutional code.

1. The sender performs a CNOT from qubit to qubit in every frame where qubit is in a frame delayed by . The effect on the binary polynomial matrix is to multiply column by and add the result to column in the “X” matrix and to multiply column by and add the result to column in the “Z” matrix.

2. A Hadamard on qubit swaps column in the “X” matrix with column in the “Z” matrix.

3. A phase gate on qubit adds column from the “X” matrix to column in the “Z” matrix.

4. A controlled-phase gate from qubit to qubit in a frame delayed by multiplies column in the “X” matrix by and adds the result to column in the “Z” matrix. It also multiples column in the “X” matrix by and adds the result to column in the “Z” matrix.

5. A controlled-phase gate from qubit to qubit in a frame delayed by multiplies column in the “X” matrix by and adds the result to column in the “Z” matrix.

We use finite-depth operations extensively in this work, but we employ only the above Hadamard and CNOT gates because our entanglement-assisted quantum convolutional codes have the CSS structure. Figure 4 gives an example of an entanglement-assisted quantum convolutional code that employs several finite-depth operations. The circuit encodes a stream of information qubits with the help of ebits shared between sender and receiver.

Multiple CNOT gates can realize an elementary column operation as described at the end of Section II. Suppose the elementary column operation multiplies column in the “X” matrix by and adds the result to column . Polynomial is a summation of some finite set of powers of :

 f(D)=Dl1+⋯+Dln.

We can realize by performing a CNOT gate from qubit to qubit in a frame delayed by for each .

## Iv CSS Entanglement-Assisted Quantum Convolutional Codes

An entanglement-assisted quantum convolutional code operates similarly to a standard quantum convolutional code. The main difference is that the sender and receiver share entanglement in the form of ebits. An entanglement-assisted quantum convolutional code encodes information qubits per frame with the help of ebits and ancilla qubits per frame. Figure 3 highlights the main features of the operation of an entanglement-assisted quantum convolutional code. The sender encodes a stream of quantum information using both additional ancillas and ebits. The sender performs the encoding operations on her qubits only (i.e., not including the halves of the ebits in possession of the receiver). The encoding operations have a periodic structure so that the same operations act on qubits in different frames and give the code a memory structure. The sender can perform these encoding operations in an online manner as she places more qubits in the unencoded qubit stream. The sender transmits her encoded qubits over the noisy quantum communication channel. The noisy channel does not affect the receiver’s half of the shared ebits. The receiver combines the received noisy qubits with his half of the ebits and performs measurements to diagnose errors that may occur. These measurements may overlap on some of the same qubits. The receiver then diagnoses errors using a classical technique such as Viterbi error estimation (43), reverses the errors that the channel introduces, and finally performs an online decoding circuit that outputs the original information qubit stream.

Our main theorem below allows us to import two arbitrary classical convolutional codes for use as a CSS entanglement-assisted quantum convolutional code. Grassl and Rötteler were the first to construct CSS quantum convolutional codes from two classical binary convolutional codes that satisfy an orthogonality constraint—the polynomial parity check matrices and of the two classical codes are orthogonal with respect to the shifted symplectic product (33):

 H1(D)HT2(D−1)=0. (12)

The resulting symplectic code has a self-orthogonal parity-check matrix when we join them together using the CSS construction. Our theorem generalizes the work of Grassl and Rötteler because we can import two arbitrary classical binary convolutional codes—the codes do not necessarily have to obey the self-orthogonality constraint.

The theorem gives a direct way to compute the amount of entanglement that the code requires. The number of ebits required is equal to the rank of a particular matrix derived from the check matrices of the two classical codes. It generalizes an earlier theorem that determines the amount of entanglement required for an entanglement-assisted quantum block code (13).

Theorem 1 also provides a formula to compute the performance parameters of the entanglement-assisted quantum convolutional code from the performance parameters of the two classical codes. This formula ensures that high-rate classical convolutional codes produce high-rate entanglement-assisted quantum convolutional codes. Our constructions also ensure high performance for the “trade-off” and “catalytic” rates by minimizing the number of ebits that the codes require.

We begin the proof of the theorem in this section and complete it in different ways for each of our two classes of entanglement-assisted quantum convolutional codes in Sections V and VII. The proofs detail how to encode a stream of information qubits, ancilla qubits, and shared ebits into a code that has the CSS structure.

###### Theorem 1.

Let and be the respective check matrices corresponding to noncatastrophic, delay-free encoders for classical binary convolutional codes and . Suppose that classical code encodes information bits with bits per frame where . The respective dimensions of and are thus and . Then the resulting entanglement-assisted quantum convolutional code encodes information qubits per frame and is an entanglement-assisted quantum convolutional code. The code requires ebits per frame where is equal to the rank of .

Let us begin the proof of the above theorem by constructing an entanglement-assisted quantum convolutional code. Consider the following quantum check matrix in CSS form:

 [H1(D)0∣∣ ∣∣0H2(D)]. (13)

We label the above matrix as a “quantum check matrix” for now because it does not necessarily correspond to a commuting stabilizer. The quantum check matrix corresponds to a set of Pauli sequences whose error-correcting properties are desirable.

The following lemma begins the proof of the above theorem. It details an initial decomposition of the above quantum check matrix for each of our two classes of entanglement-assisted quantum convolutional codes.

###### Lemma 1.

Elementary row and column operations relate the quantum check matrix in (13) to the following matrix

 [E(D)F(D)00∣∣ ∣∣00I0].

where is dimension , is , the identity matrix is , and the null matrix on the right is . We give a definition of and in the following proof.

###### Proof.

The Smith form (44) of for each  is

 Unknown environment 'array% (14)

where is , the matrix in brackets is , and is (44). Let  be the first rows of and let be the last rows of :

 Bi(D)=[Bia(D)Bib(D)].

The identity matrix in brackets in (14) indicates that the invariant factors of for each are all equal to one (44). The invariant factors are all unity for both check matrices because the check matrices correspond to noncatastrophic, delay-free encoders (44). The matrices and are a product of a sequence of elementary row and column operations respectively (44).

Premultiplying by gives a check matrix for each . Matrix is a check matrix for code with equivalent error-correcting properties as  because row operations relate the two matrices. This new check matrix  is equal to the first rows of matrix :

 H′i(D)=Bia(D).

The invariant factors of are equivalent to those of because they are related by row and column operations (44):

 H1(D)HT2(D−1)=A1(D)H′1(D)H′T2(D−1)AT2(D−1). (15)

We now decompose the above quantum check matrix into a basic form using elementary row and column operations. The row operations have no effect on the error-correcting properties of the code, and the column operations correspond to elements of an encoding circuit. We later show how to incorporate ebits so that the quantum check matrix forms a valid commuting stabilizer.

Perform the row operations in matrices for both check matrices . The quantum check matrix becomes

 [B1a(D)0∣∣ ∣∣0B2a(D)]. (16)

The error-correcting properties of the above generators are equivalent to those of the generators in (13) because row operations relate the two sets of generators. The matrix corresponds to a sequence of elementary column operations :

 B2(D)=B2,1(D)⋯B2,l(D)=l∏i=1B2,i(D).

The inverse matrix is therefore equal to the above sequence of operations in reverse order:

 B−12(D)=B2,l(D)⋯B2,1(D)=1∏i=lB2,i(D).

Perform the elementary column operations in with CNOT and SWAP gates (31). The effect of each elementary column operation is to postmultiply the “X” matrix by and to postmultiply the “Z” matrix by . Therefore the effect of all elementary operations is to postmultiply the “Z” matrix by because

 1∏i=lBT2,i(D−1)=(l∏i=1B2,i(D−1))T=BT2(D−1).

The quantum check matrix in (16) becomes

 Missing or unrecognized delimiter for \right (17)

Let be equal to the first rows and columns of the “Z” matrix:

 E(D)≡B1,a(D)BT2,a(D−1),

and let be equal to the first rows and last columns of the “Z” matrix:

 F(D)≡B1,a(D)BT2,b(D−1).

The quantum check matrix in (17) is then equivalent to the following matrix

 [E(D)F(D)00∣∣ ∣∣00I0], (18)

where each matrix above has the dimensions stated in the theorem above.∎

The above operations end the initial set of operations that each of our two classes of entanglement-assisted quantum convolutional codes employs. We outline the remaining operations for each class of codes in what follows.

## V Entanglement-Assisted Quantum Convolutional Codes with Finite-Depth Encoding and Decoding Circuits

This section details entanglement-assisted quantum convolutional codes in our first class. Codes in the first class admit an encoding and decoding circuit that employ finite-depth operations only. The check matrices for codes in this class have a property that allows this type of encoding and decoding. The following lemma gives the details of this property, and the proof outlines how to encode and decode this class of entanglement-assisted quantum convolutional codes.

###### Lemma 2.

Suppose the Smith form of is

 Unknown environment '%

where is an matrix, is an matrix, is a diagonal matrix whose entries are powers of , and the matrix in brackets has dimension . Then the resulting entanglement-assisted quantum convolutional code has both a finite-depth encoding and decoding circuit.

###### Proof.

We begin the proof of this theorem by continuing where the proof of Lemma 1 ends. The crucial assumption for the above lemma is that the invariant factors of are all powers of . The Smith form of in (18) therefore becomes

 A−11(D)A(D)[Γ(D)000]B(D)A−12(D),

by employing the hypothesis of Lemma 2 and (15). The rank of both and is equal to .

Perform the inverse of the row operations in on the first rows of the quantum check matrix in (18). Perform the inverse of the column operations in matrix on the first columns of the quantum check matrix in (18). We execute these column operations with Hadamard, CNOT, and SWAP gates. These column operations have a corresponding effect on columns in the “X” matrix, but we can exploit the identity matrix in the last rows of the “X” matrix to counteract this effect. We perform row operations on the last rows of the matrix that act as the inverse of the column operations, and therefore the quantum check matrix in (18) becomes

 ⎡⎢ ⎢ ⎢ ⎢ ⎢⎣Γ(D)0F1(D)00F2(D)000000∣∣ ∣ ∣ ∣ ∣∣000000I000I0⎤⎥ ⎥ ⎥ ⎥ ⎥⎦,

where and are the first and  respective rows of . We perform Hadamard and CNOT gates to clear the entries in in the “Z” matrix above. The quantum check matrix becomes

 ⎡⎢ ⎢ ⎢ ⎢ ⎢⎣Γ(D)0000F2(D)0000I0∣∣ ∣ ∣ ∣ ∣∣000000I00000⎤⎥ ⎥ ⎥ ⎥ ⎥⎦. (19)

The Smith form of is

 F2(D)=AF(D)[ΓF(D)0]BF(D),

where is a diagonal matrix whose entries are powers of , is , and is . The Smith form of takes this particular form because the original check matrix is noncatastrophic and column operations with Laurent polynomials change the invariant factors only up to powers of .

Perform row operations corresponding to on the second set of rows with in (19). Perform column operations corresponding to on columns with Hadamard, CNOT, and SWAP gates. The resulting quantum check matrix has the following form:

 ⎡⎢ ⎢ ⎢ ⎢ ⎢⎣Γ(D)00000ΓF(D)000000I00∣∣ ∣ ∣ ∣ ∣∣00000000I0000000⎤⎥ ⎥ ⎥ ⎥ ⎥⎦. (20)

We have now completed the decomposition of the original quantum check matrix in (13) for this class of entanglement-assisted quantum convolutional codes. It is not possible to perform row or column operations to decompose the above matrix any further. The problem with the above quantum check matrix is that it does not form a valid quantum convolutional code. The first set of rows with matrix are not orthogonal under the shifted symplectic product to the third set of rows with the identity matrix on the “X” side. Equivalently, the set of Pauli sequences corresponding to the above quantum check matrix do not form a commuting stabilizer. We can use entanglement shared between sender and receiver to solve this problem. Entanglement adds columns to the above quantum check matrix to resolve the issue. The additional columns correspond to qubits on the receiver’s side. We next show in detail how to incorporate ancilla qubits, ebits, and information qubits to obtain a valid stabilizer code. The result is that we can exploit the error-correcting properties of the original code to protect the sender’s qubits.

Consider the following check matrix corresponding to a commuting stabilizer:

 ⎡⎢ ⎢ ⎢ ⎢⎣II000000I00000000I00∣∣ ∣ ∣ ∣∣0000000000II00000000⎤⎥ ⎥ ⎥ ⎥⎦, (21)

where the identity matrices in the first and third sets of rows each have dimension , the identity matrix in the second set of rows has dimension , and the identity matrix in the fourth set of rows has dimension . The first and third sets of  rows stabilize a set of ebits shared between Alice and Bob. Bob possesses the “left”  qubits and Alice possesses the “right”  qubits. The second and fourth sets of rows stabilize a set of ancilla qubits that Alice possesses. The stabilizer therefore stabilizes a set of ebits, ancilla qubits, and information qubits.

Observe that the last columns of the “Z” and “X” matrices in the above stabilizer are similar in their layout to the entries in (20). We can delay the rows of the above stabilizer by an arbitrary amount to obtain the desired stabilizer. So the above stabilizer is a subcode of the following stabilizer in the sense of Ref. (31):

 ⎡⎢ ⎢ ⎢ ⎢ ⎢⎣Γ(D)Γ(D)000000ΓF(D)00000000I00∣∣ ∣ ∣ ∣ ∣∣0000000000II00000000⎤⎥ ⎥ ⎥ ⎥ ⎥⎦.

The stabilizer in (21) has equivalent error-correcting properties to and the same asymptotic rate as the above desired stabilizer. The above stabilizer matrix is an augmented version of the quantum check matrix in (20) that includes entanglement. The sender performs all of the encoding column operations detailed in the proofs of this lemma and Lemma 1 in reverse order. The result of these operations is an entanglement-assisted quantum convolutional code with the same error-correcting properties as the quantum check matrix in (13). The receiver decodes the original information-qubit stream by performing the column operations in the order presented. The information qubits appear as the last in each frame of the stream (corresponding to the columns of zeros in both the “Z” and “X” matrices above).∎

###### Example 1.

Consider a classical convolutional code with the following check matrix:

 H(D)=[1+D21+D+D2].

We can use in an entanglement-assisted quantum convolutional code to correct for both bit-flip errors and phase-flip errors. We form the following quantum check matrix:

 [1+D21+D+D200∣∣ ∣∣001+D21+D+D2]. (22)

This code falls in the first class of entanglement-assisted quantum convolutional codes because .

We do not show the decomposition of the above check matrix as outlined in Lemma 2, but instead show how to encode it starting from a stream of information qubits and ebits. Each frame has one ebit and one information qubit.

Let us begin with a polynomial matrix that stabilizes the unencoded state:

 [110000∣∣∣000110].

Alice possesses the two qubits on the “right” and Bob possesses the qubit on the “left.” We label the middle qubit as “qubit one” and the rightmost qubit as “qubit two.” Alice performs a CNOT from qubit one to qubit two in a delayed frame and a CNOT from qubit one to qubit two in a frame delayed by two. The stabilizer becomes

 [110000∣∣∣00011D+D2].

Alice performs Hadamard gates on both of her qubits. The stabilizer becomes

 [10001D+D2∣∣ ∣∣010100].

Alice performs a CNOT from qubit one to qubit two in a delayed frame. The stabilizer becomes

 [1000DD+D2∣∣ ∣∣01D100].

Alice performs a CNOT from qubit two to qubit one in a delayed frame. The stabilizer becomes

 [1000D1+D+D2∣∣ ∣∣01+D2D100].

Alice performs a CNOT from qubit one to qubit two. The stabilizer becomes

 [10001+D21+D+D2∣∣ ∣∣01+D21+D+D2100].

A row operation that switches the first row with the second row gives the following stabilizer:

 [01+D21+D+D2100∣∣ ∣∣10001+D21+D+D2].

The entries on Alice’s side of the above stabilizer have equivalent error-correcting properties to the quantum check matrix in (22). Figure 4 illustrates how the above operations encode a stream of ebits and information qubits for our example.

#### Discussion

Codes in the first class are more useful in practice than those in the second because their encoding and decoding circuits are finite depth. An uncorrected error propagates only to a finite number of information qubits in the decoded qubit stream. Codes in the first class therefore do not require any assumptions about noiseless encoding or decoding.

The assumption about the invariant factors in the Smith form of  holds only for some classical check matrices. Only a subclass of classical codes satisfy this assumption, but it still expands the set of available quantum codes beyond those whose check matrices and are orthogonal. We need further techniques to handle the classical codes for which this assumption does not hold. The following sections provide these further techniques to handle a larger class of entanglement-assisted quantum convolutional codes.

## Vi Infinite-Depth Clifford Operations

We now introduce a new type of operation, an infinite-depth operation, to the set of operations in the shift-invariant Clifford group available for encoding and decoding quantum convolutional codes. We require infinite-depth operations to expand the set of classical convolutional codes that we can import for quantum convolutional coding.

###### Definition 3.

An infinite-depth operation can transform a finite-weight stabilizer generator to one with infinite weight (but does not necessarily do so to every finite-weight generator).

A decoding circuit with infinite-depth operations on qubits sent over the noisy channel is undesirable because it spreads uncorrected errors infinitely into the decoded information qubit stream. But an encoding circuit with infinite-depth operations is acceptable if we assume a communication paradigm in which the only noisy process is the noisy quantum channel.

We later show several examples of circuits that include infinite-depth operations. Infinite-depth operations expand the possibilities for quantum convolutional circuits in much the same way that incorporating feedback expands the possibilities for classical convolutional circuits.

We illustrate the details of several infinite-depth operations for use in an entanglement-assisted quantum convolutional code. We first provide some specific examples of infinite-depth operations and then show how to realize an arbitrary infinite-depth operation.

We consider both the stabilizer and the logical operators for the information qubits in our analysis. Tracking both of these sets of generators is necessary for determining the proper decoding circuit when including infinite-depth operations.

### vi.1 Examples of Infinite-Depth Operations

Our first example of an infinite-depth operation involves a stream of information qubits and ancilla qubits. We divide the stream into frames of three qubits where each frame has two ancilla qubits and one information qubit. The following two generators and each of their three-qubit shifts stabilize the qubit stream:

 ⋯∣∣∣IIIIII∣∣∣ZIIIZI∣∣∣IIIIII∣∣∣⋯ (23)

The binary polynomial matrix corresponding to this stabilizer is as follows:

 [100010∣∣∣000000]. (24)

We obtain any Pauli sequence in the stabilizer by multiplying the above rows by a power of and applying the inverse of the P2B isomorphism. The logical operators for the information qubits are as follows:

 ⋯∣∣∣IIIIII∣∣∣IIXIIZ∣∣∣IIIIII∣∣∣⋯

They also admit a description with a binary polynomial matrix:

 [000001∣∣∣001000]. (25)

We refer to the above matrix as the “information-qubit matrix.”

#### Encoding

Suppose we would like to encode the above stream so that the following generators stabilize it:

 ⋯∣∣∣IIIIII∣∣∣XXXZZI∣∣∣XXIIII∣∣∣⋯,

or equivalently, the following binary polynomial matrix stabilizes it:

 [000110∣∣∣D+1D+11000]. (26)

We encode the above stabilizer using a combination of finite-depth operations and an infinite-depth operation. We perform a Hadamard on the first qubit in each frame and follow with a CNOT from the first qubit to the second and third qubits in each frame. These operations transform the matrix in (24) to the following matrix

 [000110∣∣∣111000],

or equivalently transform the generators in (23) to the following generators:

 ⋯∣∣∣IIIIII∣∣∣XXXZZI∣∣∣IIIIII∣∣∣⋯

The information-qubit matrix becomes

 [000101∣∣∣001000].

We now perform an infinite-depth operation: a CNOT from the third qubit in one frame to the third qubit in a delayed frame and repeat this operation for all following frames. Figure 5 shows this operation acting on our stream of qubits with three qubits per frame.

The effect of this operation is to translate the above stabilizer generators as follows:

 ⋯∣∣∣IIIIII∣∣∣XXXZZI∣∣∣IIXIII∣∣∣IIXIII∣∣∣⋯

The first generator above and each of its three-qubits shifts is an infinite-weight generator if the above sequence of CNOTs acts on the entire countably-infinite qubit stream. We represent the above stabilizer with the binary rational polynomial matrix

 [000110∣∣∣111/(1+D)000], (27)

where is a repeating fraction. The operation is infinite-depth because it translates the original finite-weight stabilizer generator to one with infinite weight.

It is possible to perform a row operation that multiplies the first row by . This operation gives a stabilizer matrix that is equivalent to the desired stabilizer in (26). The receiver of the encoded qubits measures the finite-weight stabilizer generators in (26) to diagnose errors. These measurements do not disturb the information qubits because they also stabilize the encoded stream.

The above encoding operations transform the information-qubit matrix as follows:

 [000101+D−1∣∣ ∣∣001/(1+D)000]. (28)

The infinite-depth operation on the third qubit has an effect on the “Z” or left side of the information-qubit matrix as illustrated in the second row of the above matrix. The effect is to multiply the third column of the “Z” matrix by if the operation multiplies the third column of the “X” matrix by . This corresponding action on the “Z” side occurs because the commutation relations of the Pauli operators remain invariant under quantum gates, or equivalently, the shifted symplectic product remains invariant under column operations. The original shifted symplectic product for the logical operators is one, and it remains as one because .

#### Decoding

We perform finite-depth operations to decode the stream of information qubits. Begin with the stabilizer and information-qubit matrix in (27) and (28) respectively. Perform a CNOT from the first qubit to the second qubit. The stabilizer becomes

 [000010∣∣∣101/(1+D)000],

and the information-qubit matrix does not change. Perform a CNOT from the third qubit to the first qubit in the same frame and in a delayed frame. These gates multiply column three in the “X” matrix by and add the result to column one. The gates also multiply column one in the “Z” matrix by and add the result to column three. The effect is as follows on both the stabilizer

 [000010∣∣∣001/(1+D)000], (29)

and the information-qubit matrix

 [000100∣∣∣101/(1+D)000]. (30)

We can multiply the logical operators by any element of the stabilizer and obtain an equivalent logical operator (4). We perform this multiplication in the “binary-polynomial picture” by adding the first row of the stabilizer in (29) to the first row of (30). The information-qubit matrix becomes

 [000100∣∣∣100000], (31)

so that the resulting logical operators act only on the first qubit of every frame. We have successfully decoded the information qubits with finite-depth operations. The information qubits teleport coherently (45); (46) from being the third qubit of each frame as in (25) to being the first qubit of each frame as in (31). We exploit the above method of encoding with infinite-depth operations and decoding with finite-depth operations for the class of entanglement-assisted quantum convolutional codes in Section VII.