This work expands a previous block-partitioned quantum cellular automata (BQCA) model proposed by Brennen and Williams [Phys. Rev. A. **68**, 042311 (2003)] to incorporate physically realistic error models. These include timing errors in the form of over- and under-rotations of quantum states during computational gate sequences, stochastic phase and bit flip errors, as well as undesired two-bit interactions occurring during single-bit gate portions of an update sequence. A compensation method to counteract the undesired pairwise interactions is proposed and investigated. Each of these error models is implemented using Monte Carlo simulations for stochastic errors and modifications to the prescribed gate sequences to account for coherent over-rotations. The impact of these various errors on the function of a QCA gate sequence is evaluated using the fidelity of the final state calculated for four quantum information processing protocols of interest: state transfer, state swap, GHZ state generation, and entangled pair generation.

## I. INTRODUCTION

Quantum Cellular Automata (QCA) have been a focus of recent work for several reasons. First, they are of interest because, as a quantum generalization of cellular automata, they have been shown to be capable of universal quantum computation.^{1–8} Second, QCA allow implementation of specific quantum information processing tasks with applications to quantum cryptography,^{9} entanglement generation,^{10,11} quantum state transfer,^{11–13} and phase covariant cloning.^{14} Finally there is a body of recent work focusing on the emergence of quantum field theory from an underlying QCA model.^{15–19} Different implementations of QCA have been proposed^{20,21} with some fundamental similarities. In particular, the essential aspect of QCA is that it largely eliminates the need for single-bit addressability which is often necessary in other architectures for quantum computing. Physically a 1D QCA implementation consists of a linear array of qubits that carry out operations through pairwise interactions and single bit operations carried out in parallel on all bits through globally applied fields. This could potentially be a substantial improvement over the traditional quantum computing paradigm in terms of the practical feasibility of implementing such a system. Moreover, QCA takes advantage of naturally occurring pairwise interactions to implement two qubit gates.

The current work builds on the QCA proposal of Brennen and Williams (so-called block partitioned QCA),^{11} a 1-dimensional QCA that assumes only nearest-neighbor interactions between the qubits. The QCA consists of 2 species of qubits, an even-ordered species *A* and an odd-ordered species *B*. The two species are updated in parallel one after the other, i.e. an update on the *B* species, followed by an update on the *A* species. Note that this is a common feature of QCA as a method to circumvent the no-cloning theorem^{14,22} which forbids the copying of a quantum state; there is no way to copy and store the state of the qubits before an update in order to update all cells simultaneously as in classical cellular automata. This QCA allows for either periodic boundary conditions, or boundaries with auxiliary qubits fixed in a particular state at the ends of a chain. It is worth noting that this QCA structure meets the minimum requirements^{6,23} for being able to simulate a QC, provided one allows for a sequence of update rules to be used. Although we have adopted the specific block-partitioned QCA structure we note that it has been shown that the different QCA structures have equivalent capabilities in the sense that they can simulate one another.^{6,7} Also note that the requirement for classical control to apply a chosen sequence of global one- and two-bit operations is not fundamental — a QCA with classical control can be implemented instead as a fully autonomous QCA.^{24}

Of course, as is the case with any quantum system, decoherence could potentially affect a QCA in the form of unintended interactions with the environment in which the system exists and imperfect application of the classical control fields necessary to implement the desired operations. The viability of QCA as a platform for quantum computing will depend at least in part upon how tolerant it is to errors. Much work has been done on error correction and the modeling of decoherence when it comes to traditional quantum computing,^{25,26} but at present little investigation of these effects on QCA has been done with the notable exceptions of Refs. 12,13,27–29. The goal herein is to extend the previous calculations from Ref. 11 with errors caused by stochastic bit- and phase-flips and coherent over-rotation caused by intensity or timing errors in the classical control fields in order to investigate the consequences of decoherence effects on 1D block-partitioned QCA.

The structure of the paper is as follows. In Sec. II we describe the block partitioned QCA (BQCA) structure. In Sec. III we describe the quantum state transfer, state swap, GHZ generation and entangled pair generation protocols as they are implemented in the BQCA. Three types of errors and their impact on the performance of the protocols are discussed in Sec. IV. We conclude in Sec. V.

## II. BQCA STRUCTURE

We consider a linear array of *n* qubits of two alternating species *A* and *B* which can be addressed separately by globally applied fields with different polarizations or resonant frequencies. A gate sequence consists of both single-bit portions which perform some unitary operation on a given species of qubit and two-qubit gates which, in this scheme, correspond to local interspecies pairwise interactions between neighboring qubits. Constructing a general gate sequence for BQCA is discussed in,^{11} and this will not be recapitulated in great detail here—only the crucial parts needed to understand the operations used in the context of this paper are presented.

It is first necessary to be able to define an operator which acts on a single qubit subsystem of the QCA. As an example, the Pauli $\sigma k$ operator which acts on the *i*-th subsystem is defined as

where *k* = *x*,*y*,*z*. Similarly, the $\sigma k$ operator which acts on all even-ordered subsystems is the sum of even operators defined as above:

with a similar sum over odd-ordered subsystems to define $\sigma kB$. The interaction Hamiltonian which implements two-qubit gates is

For the gate sequences discussed herein an operator which rotates about the Bloch vector $m\u2192=(sin\pi 4,0,cos\pi 4)$ is also required. For the *A* species this is

with a similar construction for the *B* species. Assembling these pieces as prescribed in Ref. 11 gives the desired update rule which, among other things, can be used to transport quantum information along the chain of qubits. It updates the *A* species of a QCA with ancillary boundary qubits fixed in the state $|0\u27e9$

and similarly for the *B* species

These describe a sequence of steps to perform on the system, meaning that read from right to left *M*^{A} says to apply a $\sigma m\u2192$ update to the *A* species, then apply a $\sigma z$ update the *A* species, followed by allowing the system to evolve undisturbed via pairwise coupling between qubits, a $\sigma z$ update on just the first qubit (this comes from the boundary conditions for the pairwise interaction), and finally apply a $\sigma m\u2192$ update to the *A* species. This sequence of steps, each executed by the global application of an appropriate classical control field with an integrated intensity necessary to implement a coherent rotation by the angle accompanying the operator in the exponent, completes one *M*^{A} update. It is often convenient to define one update step as

## III. QUANTUM INFORMATION PROCESSING PROTOCOLS

The protocols that follow, including the spatial transfer and exchanging of quantum information and the distribution of entanglement among a system of qubits, represent some of the basic operations one would need to be able to perform in order to build up more complicated quantum information processing tasks. The hope is therefore that they will be a representative platform for investigating the effects of the various proposed error models.

We characterize the performance of these protocols by calculating the fidelity of the output state. When we introduce errors to these protocols we adopt a quantum trajectory approach^{30,31} where we assume the environment is perfectly monitored so that the system remains, for any single realization of the error sequence, in a pure state. Of course if the error sequence was known then the errors could be corrected and the protocols would perform perfectly. We assume that, in fact, no knowledge of the error sequence is available and therefore we do not correct the state. We calculate the fidelity of the error-modified state and then average over many different realizations of the error sequence to evaluate the average fidelity. This gives a uniform computational approach to handle stochastic bit- and phase-flip errors as well as coherent over-rotations caused by intensity and/or timing errors in the classical control fields or the unintended application of the pairwise two-bit interaction in Eq. (3) during the single-bit rotations. In general the fidelity takes the form

where $|\psi f\u27e9$ is the desired error free output state and $\rho f$ is the actual output state which has been traced over the QCA qubits which are not actually part of $|\psi f\u27e9$. The details of the partial trace will depend on the particular protocol considered.

### A. State transfer

The character of this protocol is straightforward—start with a seed qubit on one end of a chain initialized to some arbitrary state

and transfer this state through intermediary qubits initialized to the state $|0\u27e9$. After the appropriate sequence of QCA gates have been applied the state is transferred to the qubit at the opposite end of the chain. The update sequence that will accomplish this in terms of *M* as defined in Eq. 7 is

The resulting space-time diagram which plots the excitation probability for each qubit at each application of *M* is shown in Fig. 1. The simulation was run for *n* = 10 qubits, resulting in 5 applications of *M*.

When considering various errors in the update sequence, it will be necessary to calculate the fidelity of the transferred state. For the state of the last qubit calculated with no errors $|\psi c\u27e9=|\psi i\u27e90$ (this denotes the initial state of the first qubit which should be losslessly transferred) and the state of the entire system calculated with errors $|\psi f\u2032\u27e9$, the fidelity squared is

where $\rho n\u22121=Tr{0,\u2026,n\u22122}(|\psi f\u2032\u27e9\u27e8\psi f\u2032|)$ is the reduced density matrix for the last qubit obtained by taking a partial trace over all but the last subsystem.

### B. State swap

The goal of this protocol is to start with qubits seeded to arbitrary states on either end of the chain, and swap the states between the ends.

The gate sequence to achieve the swap is

The spacetime diagram for the state swap protocol is shown in Fig. 2.

Again it is useful to define fidelity squared in terms of the correct final state of the first and last qubits $|\psi c\u27e9=|\psi i\u27e9n\u22121\u2297|\psi i\u27e90$ and the state of the entire system obtained with errors $|\psi f\u2032\u27e9$ as

where $\rho {0,n\u22121}$ is the reduced density matrix for the first and last subsystems.

### C. GHZ state generation

The goal of this protocol is to create an *n*-bit Greenberger-Horne-Zeilinger (GHZ) state of the qubits. We start with the central qubit seeded in the state $12(|0\u27e9+|1\u27e9)$ and end with all qubits maximally entangled in a GHZ state. The location of the “central” qubit is the *n*/2 − 1 site. The initial state can therefore be constructed as

and the update sequence is

when *n* = 4*k* or

when *n* = 4*k*+2 with *k* a positive integer. The spacetime diagram for GHZ state preparation is shown in Fig. 3.

The fidelity squared expressed in terms of the correct final state $|\psi f\u27e9$ and the state obtained with errors $|\psi f\u2032\u27e9$ is

Note that there is no partial trace in this case, because the final state involves entanglement between all qubits and hence the fidelity must account for all subsystems.

### D. Entangled pair generation

The goal of this protocol is to prepare the qubits at the ends of the chain in an entangled Bell state. The first update which distributes the initial state in the central qubit to the adjacent pairs of qubits requires a new update rule other than *M* from Eq. 7. This update rule *M*_{2}^{11,32} is

This starting state is the same as it was for the task of generating a GHZ state as in Eq. 15. Again, it starts with the central qubit (the *n*/2 − 1 site) seeded in the state $12(|0\u27e9+|1\u27e9)$. After the update sequence, the two qubits at the ends will be maximally entangled with one another. The total update sequence to accomplish this is

when *n* = 4*k* or

when *n* = 4*k*+2 with *k* a positive integer. The spacetime diagram for the entangled pair preparation is shown in Fig. 4.

The fidelity for this protocol is calculated in a similar manner as for the state swap protocol (Eq. 14) with $|\psi c\u27e9=12(|0\u27e90|0\u27e9n\u22121+|1\u27e90|1\u27e9n\u22121)$.

## IV. ERROR MODELS

In this section we describe three different error models and present results for the decay of the average fidelity of the output state as a function of the error probability per qubit for each protocol and each type of error. We consider stochastic bit- and phase-flip errors, applied at each step of the protocol, timing errors which give rise to coherent over-rotation errors, and errors arising from undesired two-qubit interactions which occur continuously, even during the application of single-bit operations. We neglect initialization errors and measurement errors as these do not occur during the time evolution of the QCA. In particular, measurement errors will have only minimal impact on a QCA as the basic structure of QCA is measurement free until the readout of the state at the end of the process. Even quantum error correction can be incorporated into a QCA with measurements applied only at the ends of the array of qubits.^{28,29} All numerical simulations were performed using the Quantum Toolbox in Python (QuTiP) package.^{33,34}

### A. Bit and phase flip errors

In this error model, spontaneous bit flips ($\sigma x$) and phase flips ($\sigma z$) have some probability of occurring. At each update, each qubit has a probability $\delta $ of receiving an error; bit and phase flips are equally likely. As is shown in Fig. 5, for the state transfer protocol fidelity falls rapidly as $\delta $ increases, settling eventually at the expected fidelity between two random quantum states.^{35} To be clear, the decay in fidelity shown in Fig. 5 is an ensemble behavior resulting from the average of many independent trials. This is essentially a Monte Carlo approach, and members of the ensemble at a given $\delta $ may have any fidelity in the interval [0,1].

In a practical scenario, it is likely that the probability for this type of error would be non-zero, but small. As such it is perhaps most interesting to consider the region where $\delta $ is small. To this end, the plots in Fig. 5 were truncated at the vertical dotted line, leaving $\delta \u2208[0,0.05]$. Table I lists the slope of a linear regression fit to this small error region for each of the model protocols. The QCA becomes more sensitive to errors as the number of qubits increases as one might expect because there are more locations for errors to occur at each time step and more time steps are required to complete the protocol. As more qubits are included in the final state the system becomes more sensitive to errors with the state swap protocol roughly twice as sensitive to errors as the state transfer protocol. Perhaps surprisingly, the state swap protocol is more sensitive than the entangled pair protocol. We attribute this to the fact that both protocols involve a final state of two qubits but the entanglement production protocol has only *n*/4 + 1 steps whereas the state transfer protocol has *n*/2 + 1 steps. This is because the entanglement production protocol starts with the initialized qubit in the middle of the array and only has to transfer the state half the distance compared with the state transfer protocol which has the initialized qubits on the ends of the array.

# Qubits . | State Transfer . | State Swap . | GHZ State . | Entangled Pair . |
---|---|---|---|---|

4 | -2.9(.98) | -6.0(.99) | -5.3(.99) | -3.9(.99) |

6 | -4.1(.98) | -7.9(.99) | -6.9(.99) | -5.7(.99) |

8 | -4.9(.95) | -9.8(.98) | -11.5(.98) | -7.9(.99) |

10 | -6.2(.97) | -10.4(.96) | -12.1(.96) | -8.2(.98) |

# Qubits . | State Transfer . | State Swap . | GHZ State . | Entangled Pair . |
---|---|---|---|---|

4 | -2.9(.98) | -6.0(.99) | -5.3(.99) | -3.9(.99) |

6 | -4.1(.98) | -7.9(.99) | -6.9(.99) | -5.7(.99) |

8 | -4.9(.95) | -9.8(.98) | -11.5(.98) | -7.9(.99) |

10 | -6.2(.97) | -10.4(.96) | -12.1(.96) | -8.2(.98) |

### B. Timing errors

The application of single-bit gates to the system of qubits in a QCA are realized by globally applied control fields. The prescribed rotation angle could then be achieved by applying a field with a given intensity for a given duration of time. Moreover, the interaction portion of the update is achieved by allowing the system to evolve undisturbed for some amount of time. It is therefore reasonable to suggest that there may not be perfect precision when it comes to the intensity of the globally applied fields, nor the temporal duration of the various updates. To model this effect, errors in the rotation amount sampled from a Gaussian distribution centered at 0 with width $\sigma $ are considered. An error is assessed on every angle at every update, for example $\pi 2\u21a6\pi 2+r$ where *r* is a random value sampled from the Gaussian distribution. As was the case with random errors of the type described in the previous section, the fidelity, shown in Fig. 6, decreases with increasing $\sigma $. And so again the data is truncated and fit to a line, this time for small error distribution widths $\sigma \u2208[0,0.05]$. The values for the slope and squared sample correlation coefficient of the linear regression are reported in Table II. Again these results were obtained from a Monte Carlo type simulation. These results can be interpreted to mean that for an ensemble of systems under the effects of a Gaussian distribution of timing errors of width $\sigma \u2208[0,0.05]$, the expected average fidelity is $F2=1+m\sigma $. The general trends are similar to those for the bit and phase flip errors although in this case the entangled pair production is more sensitive than the state swap protocol.

# Qubits . | State Transfer . | State Swap . | GHZ State . | Entangled Pair . |
---|---|---|---|---|

4 | -0.8 (.98) | -1.8 (.98) | -1.7 (.96) | -4.6 (.96) |

6 | -1.6 (.97) | -3.1 (.95) | -3.3 (.98) | -6.8 (.96) |

8 | -2.2 (.98) | -4.0 (.98) | -6.2 (.98) | -7.9 (.97) |

10 | -2.7 (.97) | -4.8 (.99) | -9.6 (.98) | -8.3 (.97) |

# Qubits . | State Transfer . | State Swap . | GHZ State . | Entangled Pair . |
---|---|---|---|---|

4 | -0.8 (.98) | -1.8 (.98) | -1.7 (.96) | -4.6 (.96) |

6 | -1.6 (.97) | -3.1 (.95) | -3.3 (.98) | -6.8 (.96) |

8 | -2.2 (.98) | -4.0 (.98) | -6.2 (.98) | -7.9 (.97) |

10 | -2.7 (.97) | -4.8 (.99) | -9.6 (.98) | -8.3 (.97) |

### C. Continuous interactions

The model in Ref. 11 assumes that the pairwise interactions between qubits is somehow “turned off” during applications of single-bit fields. Turning off the pairwise coupling may not be easy to achieve physically, and in fact one feature of the QCA architecture is to take advantage of naturally occurring “always on” nearest neighbor two qubit interactions. But one might hope that the timescale of the single-bit gates is much less than the timescale of the interactions between qubits so that the undesired two-bit interactions represent a relatively small fraction of the unitary time evolution which actually occurs during the time when the single-bit gates are applied. The following modification to the update rules (Eqs. 7 & 19) aims to model interactions occurring during the application of single-bit gates by way of the introduction of an interaction parameter $\gamma $ as follows:

Here $\gamma $ represents the fraction of the unitary rotation which is actually the undesired two-qubit interaction Hamiltonian *H*_{I}. One can think of this as a representation of the relative time scales for the two-qubit versus one-qubit gates. If the time to implement the desired single bit rotation is *t*_{1} and the time to implement an equivalent two-qubit “rotation” is *t*_{2} then $\gamma =t1/t2$. Eq. 19 is modified in the same way for the entangled pair protocol but is not shown explicitly for the sake of brevity.

We show the fidelity as a function of $\gamma $ in Fig. 7. Interestingly in the case of the state transfer and swap problems shown in Figs. 7(a) and 7(b), there are large values of $\gamma $ that correspond to relatively high fidelity. Recall that the update sequence for these problems is able to transport arbitrary initial states and so it is possible that these high fidelity regions are just fortuitous occurrences that depend on the initial state that happened to be used. To investigate this, simulations were run for many random initial states in the seed qubits and averaged together. Random initial states for the seed qubits were generated as

where $\alpha $ is a random number in the range [0,1] and $\varphi $ is a random angle in the range $[0,2\pi ]$. This will therefore be guaranteed to be normalized and will sample evenly from all possible relative phases.

Fig. 8 shows the results for the same simulations as Figs. 7(a) and 7(b) but averaged over 1000 random initial states as described. It appears that the high fidelity regions are damped out by the averaging and that at high $\gamma $ the fidelity matches that expected for random states.

Again we assess the sensitivity to small errors by fitting a line to the decaying fidelity for $\gamma \u2208[0,0.05]$ for the state transfer and state swap averaged over the initial state and for $\gamma \u2208[0,0.03]$ for the GHZ preparation and entangled pair preparation. The slope and squared sample correlation coefficient of the linear regression is reported in Table III.

# Qubits . | State Transfer . | State Swap . | GHZ State . | Entangled Pair . |
---|---|---|---|---|

4 | -3.9 (.95) | -10.7 (.97) | -3.8 (.93) | -18.6 (.98) |

6 | -7.1 (.97) | -14.6 (.99) | -9.7 (.94) | -22.6 (.99) |

8 | -9.8 (.98) | -16.5 (.98) | -16.1 (.95) | -22.6 (.98) |

10 | -11.5 (.98) | -17.3 (.95) | -22.6 (.97) | -24.4 (.96) |

# Qubits . | State Transfer . | State Swap . | GHZ State . | Entangled Pair . |
---|---|---|---|---|

4 | -3.9 (.95) | -10.7 (.97) | -3.8 (.93) | -18.6 (.98) |

6 | -7.1 (.97) | -14.6 (.99) | -9.7 (.94) | -22.6 (.99) |

8 | -9.8 (.98) | -16.5 (.98) | -16.1 (.95) | -22.6 (.98) |

10 | -11.5 (.98) | -17.3 (.95) | -22.6 (.97) | -24.4 (.96) |

In order to assess the scaling of the sensitivity to errors as *n* increases we plot the slopes from Tables I–III along with a linear fit in Fig. 9. As expected the fidelity is more sensitive to errors as *n* increases because there are more locations for errors to occur. The state swap, state transfer, and entangled pair protocols have similar scaling with *n*. The performance of the GHZ preparation decreases roughly twice as quickly as *n* is increased. We attribute this to the fact that the intended final GHZ state is an *n*-qubit entangled state whereas the others are one- or two-qubit states. For the GHZ state any error will decrease the fidelity while for the other protocols some error locations will not affect the final state.

After modeling interactions occurring during the single-bit portions of the update, the question that naturally arises is whether or not this can be corrected for by decreasing the duration of the two-qubit interactions from that originally required. To test this we introduce a compensation parameter *C* which decreases the duration of the interaction portion of the update as follows,

*C* = 0 represents no reduction of the interaction time and *C* = 1 represents a reduction of the interaction time to zero. Again Eq. 19 is modified in the same way for the entangled pair problem.

Fig. 10 shows how *C* affects fidelity for the sample problems. Six different values of the interaction parameter $\gamma $, denoted by line color, are shown in each plot. Note that in all cases except for entangled pair production, for small nonzero values of $\gamma $, the fidelity increases to a value higher than it would have been with no compensation (*C* = 0). This means that in practice if pairwise couplings occur during the applications of global single-bit fields (i.e. the pairwise coupling is not turned off), it is always beneficial to reduce the duration of the pairwise interaction to correct for the fact that it is modifying the state of the system during the application of the single-bit fields. As one would expect, the value of *C* which maximizes the fidelity increases with $\gamma $. If there is more two-bit interaction during the single-bit gates then one needs less two-bit interaction in between the single-bit gates to maximize the fidelity of the protocol. This relationship is shown most clearly for the GHZ state generation protocol.

Again in the case of the transfer and swap protocols there is a question of how the behavior depends on the initial states used. To investigate this it is again useful to consider averaging over random initial states, generated as described in Eq. 23, for these protocols. From Fig. 11, it is apparent that the same features are present. In fact the average fidelity is somewhat better than for the particular initial states chosen for Fig. 10. Since the increase in the fidelity persists even in the average case one can identify an optimal value of *C* which will maximize fidelity for a given value of $\gamma $, at least for *n* = 10. Qualitatively we expect that generally the performance of the compensation would decrease with increasing *n*. For a given $\gamma $ the fidelity decreases with *n* as shown in Fig. 9(c). At the same time the magnitude of the fidelity that can be recovered via compensation seems to be relatively independent of the initial fidelity with the caveat that the fidelity cannot go above 1. This would seem to indicate that the performance should decrease with increasing *n*.

## V. CONCLUSION

This work has successfully reproduced the results of Ref. 11 for quantum state transfer, state swap, GHZ state generation, and entangled pair generation implemented in a BQCA and expanded upon those results in order to model physically relevant stochastic bit- and phase-flip errors, coherent over-rotation errors, and undesired two-bit interaction errors. These results show that the success of a BQCA update rule is very sensitive to random bit and phase flip errors assessed on the constituent qubits as well as errors in the rotation amounts prescribed in the update sequence (so-called “timing errors” herein). The decay of the fidelity with increasing error probability or increasing over-rotation errors listed in Tables I and II can be used to estimate the success rate for a protocol with *n* qubits and error rate $\delta $. The slope of the decay of the fidelity has an approximately linear dependence on the number of qubits in the range *n* = 4 to 10. With some caution this can be extrapolated to give a rough estimate of expected fidelity in systems of somewhat larger numbers of qubits than can be directly simulated.

The undesired two-qubit interactions occurring during the single-bit gates can be partially compensated by a reduction in the duration of the two-qubit interaction during the application of an update sequence. This seems to imply, with the exception of entangled pair production, that the fidelity of a QCA update sequence can often be improved by reducing the duration of the interaction portion of an update by an amount which depends on the relative timescale of the single-bit versus two-qubit gates.

Clearly it would be desirable to assess the impact of quantum error correction on these results. Unfortunately our approach is not amenable to the numbers of physical qubits that would be necessary to simulate error correction while implementing a quantum information processing protocol on a meaningful number of logical qubits. In the context of the current work the most we can say is that error correction is fundamentally compatible with the autonomous, measurement free nature of the QCA architecture.^{28,29} Further consideration of quantum error correction in the context of BQCA is contingent upon the development of a different simulation approach which accommodates a larger number of physical qubits.