# Quantum Shift Register Circuits

## Abstract

A quantum shift register circuit acts on a set of input qubits and memory qubits, outputs a set of output qubits and updated memory qubits, and feeds the memory back into the device for the next cycle (similar to the operation of a classical shift register). Such a device finds application as an encoding and decoding circuit for a particular type of quantum error-correcting code, called a quantum convolutional code. Building on the Ollivier-Tillich and Grassl-Rötteler encoding algorithms for quantum convolutional codes, I present a method to determine a quantum shift register encoding circuit for a quantum convolutional code. I also determine a formula for the amount of memory that a CSS quantum convolutional code requires. I then detail primitive quantum shift register circuits that realize all of the finite- and infinite-depth transformations in the shift-invariant Clifford group (the class of transformations important for encoding and decoding quantum convolutional codes). The memory formula for a CSS quantum convolutional code then immediately leads to a formula for the memory required by a CSS entanglement-assisted quantum convolutional code.

###### pacs:

^{1}

2008 LABEL:FirstPage1 LABEL:LastPage10

## I Introduction

With the advent of quantum computing and quantum communication, it becomes increasingly important to develop ways for protecting quantum information against the adversarial effects of noise [1]. Researchers have developed many theoretical techniques for the protection of quantum information [3]; [2]; [4]; [5]; [6]; [7]; [8]; [9]; [10]; [11]; [12]; [13] since Shor’s original contribution to the theory of quantum error correction [14].

Quantum convolutional coding is a technique for protecting a stream of quantum information [21]; [19]; [15]; [17]; [18]; [22]; [23]; [24]; [25]; [20]; [16]; [26]; [27]; [28] and is perhaps more valuable for quantum communication than it is for quantum computation (though see the tail-biting technique in Ref. [23]). Quantum convolutional codes bear similarities to classical convolutional codes [29]; [30]. The encoding circuit for a quantum convolutional code consists of a single unitary repeatedly applied to the quantum data stream [21]. Decoding a quantum convolutional code consists of applying a syndrome-based version of the Viterbi decoding algorithm [31]; [23]; [21].

The encoding circuit for a classical convolutional code has a particularly simple form. Given a mathematical description of a classical convolutional code, one can easily write down a shift register implementation for the encoding circuit [29]. For this reason among others, deep space missions such as Voyager and Pioneer used classical convolutional codes to protect classical information [32].

A natural question is whether there exists such a simple mapping from the mathematical description of a quantum convolutional code to a quantum shift register implementation. Many researchers have investigated the mathematical constructions of quantum convolutional codes, but few [19]; [15]; [17]; [18] have attempted to develop encoding circuits for them. The Ollivier-Tillich quantum convolutional encoding algorithm [19] is similar to Gottesman’s technique [4] for encoding a quantum block code. The Grassl-Rötteler encoding algorithm [15]; [17]; [18] encodes a quantum convolutional code with a sequence of elementary encoding operations. Each of these elementary encoding operations has a mathematical representation as a polynomial matrix, and each elementary encoding operation builds up the mathematical representation of the quantum convolutional code.

The Ollivier-Tillich and Grassl-Rötteler encoding algorithms leave a practical question unanswered. They both do not determine how much memory a given encoding circuit requires, and in the Grassl-Rötteler algorithm, it is not even explicitly clear how the encoding circuit obeys a convolutional structure (it obeys a periodic structure, but the convolutional structure demands that the encoding circuit consist of the same single unitary applied repeatedly on the quantum data stream).

In this paper, I develop the theory of quantum shift register circuits, using tools familiar from linear system theory [33] and classical convolutional codes [29]. I explicitly show how to connect quantum shift register circuits together so that they encode a quantum convolutional code. I develop a general technique for reducing the amount of memory that the quantum shift register encoding circuit requires. Theorem 3 of this paper answers the above question concerning memory use in a CSS quantum convolutional code—it determines the amount of memory that a given CSS quantum convolutional code requires, as a function of the mathematical representation of the code. I also show how to implement any elementary operation from the shift-invariant Clifford group [15]; [16] with a quantum shift register circuit.

These quantum shift register circuits might be of interest to experimentalists wishing to implement a quantum error-correcting code that has a simple encoding circuit, but unlike a quantum block code, has a memory structure. Classical convolutional codes were most useful in the early days of computing and communication because they have a higher performance/complexity trade-off than a block code that encodes the same number of information qubits [23]. At the current stage of development, experimentalists have the ability to perform few-qubit interactions, and it might be useful to exploit these few-qubit interactions on a quantum data stream, rather than on a single block of qubits.

Other authors have suggested the idea of a quantum shift register [34]; [35], but it is not clear how we can apply the ideas in these papers to the encoding of a quantum convolutional code. Additionally, another set of authors labeled their work as a “quantum shift register” [36], but this quantum shift register is not useful for protecting quantum information (nor is it even useful for coherent quantum operations).

The closest work to this one is the discussion in Section IIB of Ref. [37]. Though, Poulin et al. did not develop the quantum shift register idea in much detail because their focus was to develop the theory of decoding quantum turbo codes. The discussion in Ref. [37] is one of the inspirations for this work (as well as the initial work of Ollivier and Tillich [21]; [19]), and this paper is an extension of that discussion.

The most natural implementation of a quantum shift register circuit may be in a spin chain [38]; [39]. Such an implementation requires a repetition of acting with the encoding unitary at the sender’s register and allowing the Hamiltonian of the spin chain to shift the qubits by a certain amount. Further investigation is necessary to determine if this scheme would be feasible. Another natural implementation of a quantum shift register circuit is with linear optical circuits [40]. One can implement the feedback necessary for this circuit by redirecting light beams with mirrors. The difficulty with this approach is that controlled-unitary encoding is probabilistic.

I structure this work as follows. The next section begins with examples that illustrate the operation of a quantum shift register circuit. I then present a simple example of a quantum shift register circuit that encodes a CSS quantum convolutional code. This example demonstrates the main ideas for constructing quantum shift register encoding circuits. First, build a quantum shift register circuit for each elementary encoding operation in the Grassl-Rötteler encoding algorithm. Then, connect the outputs of the first quantum shift register circuit to the inputs of the next one and so on for all of the elementary quantum shift register circuits. Finally, simplify the device by determining how to “commute gates through the memory” of the larger quantum shift register circuit (discussed in more detail later). This last step allows us to reduce the amount of memory that the quantum shift register circuit requires. Section V follows this example by developing two types of finite-depth controlled-NOT (CNOT) quantum shift register circuits (I explain the definition of “finite-depth” later on). Section VI then states and proves Theorem 3—this theorem gives a formula to determine the amount of memory that a given CSS quantum convolutional code requires. I then develop the theory of quantum shift register circuits with controlled-phase gates and follow by giving the encoding circuit for the Forney-Grassl-Guha code [23]. Grassl and Rötteler stated that the encoding circuit for this code requires two frames of memory qubits [15], but I instead find with this paper’s technique that the minimum amount it requires is five frames. Section IX then develops quantum shift register circuits for infinite-depth operations, which are important for the encoding of Type II CSS entanglement-assisted quantum convolutional codes [16]. Theorem 3 also determines the amount of memory required by these codes. I then conclude with some observations and open questions.

## Ii Examples of Quantum Shift Register Circuits

Let us begin with a simple example to show how we can build up an arbitrary finite-depth CNOT operation. Consider the full set of Pauli operators on two qubits [1]; [41]:

We can form a symplectic representation of the full set of Pauli operators for two qubits with the following matrix [1]; [41]:

where the entries to the left of the vertical bar correspond to the operators and the entries to the right of the vertical bar correspond to the operators. Suppose that we perform a CNOT gate from the first qubit to the second qubit conditional on a bit . We perform the gate if and do not perform it otherwise. The above Pauli operators transform as follows:

Figure 1 depicts the “quantum shift register circuit” that implements this transformation (this device is not really a quantum shift register circuit because it does not exploit a set of memory qubits).

Let us incorporate one frame of memory qubits so that the circuit really now becomes a quantum shift register circuit. Consider the circuit in Figure 2. The first two qubits are fed into the device and the second one is the target of a CNOT gate from a future frame of qubits (conditional on the bit ). The two qubits are then stored as two memory qubits (swapped out with what was previously there). On the next cycle, the two qubits are fed out and the first qubit that was previously in memory acts on the second qubit in a frame that is in the past with respect to itself. We would expect the variable of the first outgoing qubit to propagate one frame into the past with respect to itself and the variable of the second incoming qubit to propagate one frame into the future with respect to itself. We make this idea more clear in the below analysis.

We can analyze this situation with a set of recursive equations. Let denote the bit representation of the Pauli operator for the first incoming qubit at time and let denote the bit representation of the Pauli operator for the first incoming qubit at time . Let and denote similar quantities for the second incoming qubit at time . Let denote the bit representation of the Pauli operator acting on the first memory qubit at time and let denote the bit representation of the Pauli operator acting on the first memory qubit at time . Let and denote similar quantities for the second memory qubit. In the symplectic bit vector notation, we denote the “Z” part of the Pauli operators acting on these four qubits at time as

and the “X” part by

The symplectic vector for the inputs is then

(1) |

I prefer this bit notation of Poulin et al. [37] because it is more flexible for quantum shift register circuits. It allows us to capture the evolution of an arbitrary tensor product of Pauli operators acting on these four qubits at time .

At time , the two incoming qubits and the previous memory qubits from time are fed into the quantum shift register device and the CNOT gate acts on them. The notation in Figure 2 indicates that there is an implicit swap at the end of the operation. The incoming qubits get fed into the memory, and the previous memory qubits get fed out as output. Let , , , and denote the respective output variables. The symplectic transformation for the CNOT gate is

The above matrix postmultiplies the vector in (1) to give the following output vector. We denote the “Z” part of the output Pauli operators acting on these four qubits at time as

and the “X” part by

with the change of locations corresponding to the implicit swap. The symplectic vector for the outputs is then

(2) |

It is simpler to describe the above transformation as a set of recursive “update” equations:

Some substitutions simplify this set of recursive equations so that it becomes the following set:

We can transform this set of equations into the “-domain” with the -transform [29]. The set transforms as follows:

This set of transformations is linear, and we can write them as the following matrix equation:

The factor of accounts for the unit delay necessary to implement this device, but it is not particularly relevant for the purposes of the transformation (we might as well say that this quantum shift register device implements the transformation without the factor of ). Postmultiplying the vector

by the above matrix gives the output vector

The above transformation confirms our intuition concerning the propagation of and variables. The term on the right side of the transformation matrix indicates that the variable of the first qubit propagates one frame into the past with respect to itself, and the term on the left side of the matrix indicates that the variable of the second qubit propagates one frame into the future with respect to itself.

We now consider combining the different quantum shift register circuits together. Suppose that we connect the outputs of the device in Figure 1 to the inputs of the device in Figure 2. Figure 3 depicts the resulting quantum shift register circuit, and it follows that the resulting transformation in the -domain is

(3) |

Now consider the “two-delay transformation” in Figure 4. The circuit is similar to the one in Figure 2, with the exception that the first outgoing qubit acts on the second incoming qubit and the second incoming qubit is delayed two frames with respect to the first outgoing qubit. We now expect that the variable propagates two frames into the past, while the variable propagates two frames into the future. The transformation should be as follows:

(4) |

An analysis similar to the one for the “one-delay” CNOT transformation shows that the circuit indeed implements the above transformation.

Let us connect the outputs of the device in Figure 3 to the inputs of the device in Figure 4. The resulting -domain transformation should be the multiplication of the transformation in (3) with that in (4), and an analysis with recursive equations confirms that the transformation is the following one:

(5) |

The resulting device uses three frames of memory qubits to implement the transformation. This amount of memory seems like it may be too much, considering that the output data only depends on the input from two frames into the past. Is there any way to save on memory consumption?

First, let us connect the outputs of the circuit in Figure 3 to the inputs of the circuit in Figure 4. Figure 5 depicts the resulting device. In this “combo” device, the target of the CNOT gate conditional on does not act on the source of the CNOT gate conditional on . Therefore, we can commute the “-gate” with the “-gate.” Now, we can actually then “commute this gate through the memory” because it does not matter whether this CNOT gate acts on the qubits before they pass through the memory or after they come out. It then follows that the last frame of memory qubits are not necessary because there is no gate that acts on these last qubits. Figure 6 depicts the simplified transformation. It is also straightforward to check that the resulting transformation is as follows:

(6) |

where the premultiplying delay factor in (6) is now instead of as in (5).

## Iii General Encoding Algorithm

The procedure in the previous section allows us to simplify the circuit by eliminating the last frame of memory qubits. This procedure of determining whether we can “commute gates through the memory” is a general one that we can employ for reducing memory in quantum shift register circuits. In the above example, we can determine the number of frames of memory that are necessary by considering the absolute degree of the polynomial transformation in (5) (without including the prefactor). The absolute degree of a polynomial matrix is

where

del is the lowest power in the polynomial , and the absolute degree is modulo any prefactor terms such as the in (5). In the case of the transformation in (5), the absolute degree is equal to two, so we should expect to have two frames of memory qubits. Theorem 3 generalizes this idea by showing that the absolute degree of an encoding matrix corresponds to the amount of memory that a CSS quantum convolutional code requires.

The procedure in the previous section demonstrates a general procedure for constructing quantum shift register circuits for quantum convolutional codes. We can break the encoding operation into elementary operations as the Grassl-Rötteler encoding algorithm does [17]; [15]; [18]; [16]. The general procedure implements each elementary operation with a quantum shift register circuit, connects the outputs of one quantum shift register circuit to the inputs of the next, and determines if it is possible to “commute gates through memory” as shown in the above example. This procedure produces a quantum shift register encoding circuit that uses the minimal amount of memory.

## Iv Example of a Quantum Shift Register Encoding Circuit for a CSS Quantum Convolutional Code

Let us consider a simple example of a CSS quantum convolutional code [2]; [3]. Its stabilizer matrix [19]; [15] is as follows:

(7) |

I now show how to encode the above quantum convolutional code using a slight modification of the Grassl-Rötteler encoding algorithm for CSS codes [18]. One begins with the stabilizer matrix for two ancilla qubits per frame:

The first ancilla qubit of every frame is in the state and the second ancilla qubit of every frame is in the state . First send the three qubits through a quantum shift register device that implements a CNOT. This notation indicates that there is a CNOT gate from the third qubit to the second in the same frame and to the second in a future frame. The stabilizer becomes

(8) |

Then send the three qubits through a quantum shift register device that performs a CNOT (indicating a CNOT from the first qubit in one frame to the second in a delayed frame) and another quantum shift register device that performs a CNOT. The stabilizer becomes

(9) |

and is now encoded. Note that the above circuit is a “classical” circuit in the sense that it uses only CNOT gates in its implementation. Figure 7 depicts the quantum shift register circuit corresponding to the above operations.

It again seems that the circuit in Figure 7 is wasteful in memory consumption. Is there anything we can do to simplify this circuit? First notice that the target qubit of the CNOT gate in the second quantum shift register is the same as the target qubit of the second CNOT gate in the first quantum shift register. It follows that these two gates commute so that we can act with the CNOT gate in the second quantum shift register before acting with the second CNOT gate of the first quantum shift register. But we can do even better. Acting first with the CNOT gate in the second quantum shift register is equivalent to having it act before the first frame of memory qubits gets delayed. Figure 8 depicts this simplification.

But glancing at Figure 8, it is now clear that the second quantum shift register circuit no longer serves any purpose. We may remove it from the circuit. Figure 9 displays the resulting simplified circuit.

We can apply a similar logic to the two gates in the second quantum shift register of Figure 9 because the two gates there commute with the preceding gates. Performing a similar simplification and elimination of the last frame of memory qubits leads to the final circuit. Figure 10 depicts the quantum shift register circuit that encodes this quantum convolutional code with one frame of memory qubits.

The overall encoding matrix for this code is

The absolute degree of the encoding matrix is one, and thus, this CSS code requires one frame of memory qubits. Theorem 3 generalizes this result to show that the memory of the encoding circuit for any CSS quantum convolutional code is given by the absolute degree of the encoding matrix for the circuit.

## V Primitive Quantum Shift Register Circuits for CSS Quantum Convolutional Codes

In this section, I outline some basic primitive operations that are useful building blocks for the quantum shift register circuits of CSS (and non-CSS) quantum convolutional codes. I illustrate delay elements and finite-depth CNOT operations.

### v.1 Delay Operations

The simplest operation that we can perform with a quantum shift register circuit is to delay one qubit with respect to the others in a given frame. The way to implement this operation is simply to insert a memory element on the qubit that we wish to delay. Figure 11 depicts this delay operation. Suppose that the Pauli operators for the two qubits in the example are as follows (with the convention that the “Z” operators are on the left and the “X” operators are on the right):

### v.2 Building Finite-Depth CNOT Operations

I now show how to generalize the above examples to implement a general
CNOT finite-depth operation. Suppose that we have two qubits on which we
would like to perform a finite-depth operation ^{2}

A general shift-invariant finite-depth CNOT operation translates the above set of operators to the following set:

(10) |

where is some arbitrary binary polynomial:

###### Theorem 1

Proof. The proof of this theorem uses linear system theoretic techniques by considering symplectic binary vectors that correspond to the Pauli operators for the incoming qubits, the outgoing ones, and the memory qubits. We can formulate a system of recursive equations involving these binary variables similar to how we did for the previous examples. Let us label the bit representations of the Pauli operators for all the qubits as follows:

where the primed variables are the outputs and the unprimed are the inputs. Let us label the bit representations of the Pauli operators similarly:

The circuit in Figure 12 implements the following set of recursive “X” equations:

and ,

The set of “Z” recursive equations is as follows:

and ,

Simplifying the “X” equations gives the following two equations:

Simplifying the “Z” equations gives the following two equations:

Applying the -transform to the above gives the following set of equations:

Rewriting the above set of equations as a matrix transformation reveals that it is equivalent to the transformation in (10) (modulo the factor ):

Postmultiplying the following vector by the above transformation

gives the following output vector:

The circuit in Figure 12 uses frames of memory qubits ( actual memory qubits).

Suppose now that we reverse the direction of the CNOT gates in Figure 12. The result is to perform a shift-invariant finite-depth CNOT operation “conjugate” to that in (10):

(11) |

It merely switches the roles of the and variables.

###### Theorem 2

Proof. The proof follows analogously to the above proof by noting that the recursive equations for the “X” and “Z” variables interchange after reversing the direction of the CNOT gates.

## Vi Memory Requirements for a CSS Quantum Convolutional Code

Is there a general way for determining how much memory a given code requires just by inspecting its stabilizer matrix? This section answers this question with a theorem that determines the amount of memory that a given CSS quantum convolutional code requires.

Ref. [18] defines the individual constraint length, the overall constraint length, and the memory of a quantum convolutional code in analogy to the classical definitions [29]. These definitions are analogous to the classical definitions, but there does not seem to be an operational interpretation of them in terms of the actual memory that a given quantum convolutional code requires. We recall those definitions. The constraint length for row of the stabilizer matrix is as follows:

The overall constraint length is the sum of the individual constraint lengths:

The memory is

We now consider a general technique for computing the memory requirements of a CSS quantum convolutional code, and the resulting formula does not correspond to the above definitions. We exploit the Grassl-Rötteler algorithm for encoding CSS codes [18]. This algorithm consists of a sequence of Hadamards, a cascade of CNOTs, another sequence of Hadamards, and another cascade of CNOTs. Here, I give a slightly simplfied algorithm that does not require any Hadamard gates. Suppose that a quantum convolutional code has the following stabilizer matrix:

(12) |

We can determine an encoding algorithm by looking at a series of steps to decode the above quantum convolutional code. Assume that the matrices and correspond to noncatastrophic, delay-free check matrices so that they each have a Smith normal form [29]; [18]:

where . If the matrices for are not equal to the identity matrix, we can premultiply with the inverse matrix for . These row operations do not affect the error-correcting properties of the quantum convolutional code and give an equivalent code. Let us redefine the matrices as follows:

for . We can then write each matrix as follows:

Consider again the stabilizer matrix in (12). Use CNOT gates to perform the elementary column operations in the matrix . These operations postmultiply entries in the “X” matrix with the matrix and postmultiply entries in the “Z” matrix with the matrix . The stabilizer matrix in (12) transforms to the following matrix:

The matrix is null because the code is a CSS code and satisfies the dual-containing constraint. The stabilizer matrix for the code is then as follows:

Compute the Smith form of the matrix :

Perform the row operations in on the first set of rows. Finally, perform the conjugate CNOT gates corresponding to the entries in —implying that we perform them only on the last few qubits. These operations postmultiply the “X” matrix by the matrix and postmultiply the “Z” matrix by the matrix . These operations then produce the following stabilizer matrix:

We are done at this point. These decoding operations give the following transformations for the “X” matrix:

and the following transformations for the “Z” matrix:

To encode the quantum convolutional code, we perform the above operations in the reverse order. For encoding, the following transformations postmultiply the “X” matrix:

and the following transformations for the “Z” matrix:

The overall encoding matrix is

(See Ref. [18] for a more detailed analysis of this algorithm).

I now give a theorem that determines the amount of memory that a CSS quantum convolutional code requires.

###### Theorem 3

The number of frames of memory qubits required for a CSS quantum convolutional code encoded with the Grassl-Rötteler encoding algorithm is upper bounded by the absolute degree of :

Proof. I employ an inductive method of proof. The above encoding algorithm for a CSS quantum convolutional code demonstrates that we only have to consider how CNOT gates combine together in a quantum shift register construction. We can map each elementary CNOT operation to a quantum shift register circuit and connect its outputs to the inputs of the quantum shift register circuit for the next elementary CNOT operation. This technique is wasteful with respect to memory, but the proof of this theorem shows all the ways that we can reduce the amount of memory when combining quantum shift register circuits corresponding to CNOT operations. The result of the theorem then gives a simple formula for determining the amount of memory that a CSS quantum convolutional code requires.

For the base step of the proof, consider that a CNOT gate from qubit to qubit in a frame delayed by requires at most frames of memory qubits. This result follows by extending the circuit of Figure 4. The polynomial matrix for this CNOT gate that acts on the and qubits is as follows:

and has an absolute degree of . We abbreviate the above transformation as CNOT. So the theorem holds for this base case.

Now consider two CNOT gates that have the same source qubits, but the source of one of them acts on a target qubit in a frame delayed by and the source of another acts on a target qubit in a frame delayed by . Suppose, without loss of generality, that (these integers can be negative—we should use the term “advanced by” instead of “delayed by” for this case). This combination is a special case of Theorems 1 and 2 and, therefore, we can implement this gate with frames of memory qubits. The polynomial matrix for the first CNOT is CNOT and that for the second is CNOT. It is straightforward to check that the polynomial matrix for the combined operation is CNOT. The theorem thus holds for this case because the absolute degree of CNOT is .

The theorem similarly holds if two CNOT gates have the same source qubits but have target qubits that do not have the same index within their given frame. It also holds if two CNOT gates have the same target qubits but have source qubits that do not have the same index within their given frame. The polynomial matrices for the first case are CNOT and CNOT where WLOG . These two polynomial matrices commute. One can construct a quantum shift register circuit with the techniques in this paper, and this circuit uses frames of memory qubits. It is straightforward to check that the absolute degree of the multiplication of matrices is . A similar symmetric analysis applies to the other case where the target qubits are the same but the source qubits are different. The main reason the theorem holds in these scenarios is that the polynomial matrix representations of these gates commute with one another. Any time the polynomial representations commute, the corresponding gates in the cascaded quantum shift registers commute through memory so that the maximum amount of frames of memory qubits is equal to the absolute degree of the entries in the multiplication of the polynomial matrices.

Suppose the source qubits and target qubits of the two CNOT gates do not intersect in any way. Then their polynomial matrix representations commute and the amount of memory required is again equal to the absolute degree of the polynomial matrices corresponding to the CNOT gates. An example is CNOT and CNOT where and WLOG . One can use the techniques in this paper to construct a combined quantum shift register circuit that requires frames of memory qubits.

Suppose the index of source qubit of the first CNOT gate is the same as the index of the target of the second CNOT gate, but the index of the target of the first is different from the index of the source qubit of the second. An example of this scenario is CNOT followed by CNOT where and are any integers and WLOG. The multiplication of the two polynomial matrices gives the following polynomial matrix:

where the indices , , and correspond to the first, second, and third columns of the above “Z” and “X” submatrices. It is again straightforward using the technique in this paper to construct a quantum shift register circuit that uses memory equal to the absolute degree of the above polynomial matrix. The circuit uses frames of memory qubits in the case that is positive and is negative and vice versa and uses frames of memory qubits in the case that and are both positive or both negative.

The last scenario to consider is when the index of the source qubit of the first CNOT gate is the same as the index of the target of the second CNOT gate, and the index of the target of the first CNOT gate is the same as the index of the source of the second CNOT gate. An example of this scenario is CNOT followed by CNOT, where and are any integers and WLOG. The multiplication of the two polynomial matrices gives the following polynomial matrix:

where the indices and correspond to the first and second columns of the above “Z” and “X” submatrices. It is again straightforward to construct a quantum shift register using the techniques in this paper that uses a number of frames of memory qubits equal to the absolute degree of the polynomial matrix.

The inductive step follows by considering that any arbitrary encoding with CNOTs is a sequence of elementary column operations of the form:

where is the total number of elementary operations and the above decomposition is a particular decomposition of the matrix into elementary operations. Suppose the above encoding matrix requires frames of memory qubits and is also the absolute degree of . Suppose we cascade another elementary encoding operation with matrix representation . If commutes with , then it increases the absolute degree of the resulting matrix and the memory required for the quantum shift register circuit only if it has a higher absolute degree than . The case is thus reducible to the case where it does not commute with . So, suppose does not commute with . There are two ways in which this non-commutativity can happen and I detailed them above. The analysis above for both cases shows that the absolute degree and the number of frames of memory qubits increase by the same amount depending whether and are positive or negative.

###### Corollary 4

A Type I CSS entanglement-assisted quantum convolutional code [16] encoded with the Grassl-Rötteler encoding algorithm requires frames of memory qubits, where

The matrix is the polynomial matrix representation of the encoding operations of the entanglement-assisted code.

Proof. A Type I CSS entanglement-assisted convolutional code is one that has a finite-depth encoding and decoding circuit. It is possible to show that the encoding circuit consists entirely of CNOT gates. The proof proceeds analogously to the proof of the above theorem.

## Vii Other Operations in the Finite-Depth Shift-Invariant Clifford Group

CNOT gates are not the only gates that are useful for encoding a quantum convolutional code. The Hadamard gate, the Phase gate, and the controlled-Phase gate are also useful and are in the finite-depth shift-invariant Clifford group [15].

There is no need to formulate a primitive quantum shift register circuit for the Hadamard gate or the Phase gate—the implementation is trivial and does not require memory qubits.

The controlled-phase gate is useful for implementation with a quantum shift register circuit because it acts on two qubits. There are two types of a quantum shift register circuit that we can develop with a controlled-Phase gate. The first type is similar to that for the finite-depth CNOT quantum shift register circuit because it involves two qubits per frame. The second type is different because it involves only one qubit per frame.

### vii.1 Finite-Depth Controlled-Phase Gate with Two Qubits per Frame

Suppose that we have two qubits on which we would like to perform a finite-depth controlled-Phase gate operation. The Pauli operators for these qubits are as follows:

A general shift-invariant finite-depth controlled-Phase gate operation translates the above set of operators to the following set:

(13) |

where is some arbitrary binary polynomial:

###### Theorem 5

Proof. The proof of this theorem is similar to that of the previous theorems. We can formulate a system of recursive equations involving binary variables. Let us label the bit representations of the Pauli operators for all the qubits as follows:

where the primed variables are the outputs and the unprimed are the inputs. Let us label the bit representations of the Pauli operators similarly:

The circuit in Figure 14 implements the following set of recursive “X” equations:

and ,

The set of “Z” recursive equations is as follows:

and ,

Simplifying the “X” equations gives the following two equations:

Simplifying the “Z” equations gives the following two equations: