A review of Quantum Cellular Automata

Discretizing spacetime is often a natural step towards modelling physical systems. For quantum systems, if we also demand a strict bound on the speed of information propagation, we get quantum cellular automata (QCAs). These originally arose as an alternative paradigm for quantum computation, though more recently they have been proposed as models of periodically driven (Floquet) quantum systems, where the index theory for QCAs has allowed the classification of chiral phases of two-dimensional Floquet systems. QCAs have also been suggested as a natural discretization of quantum field theory, and some interesting examples of QCAs have been introduced where a quantum field theory is recovered in the continuum limit. This review discusses all of these applications, as well as some other interesting results on the structure of quantum cellular automata, including the matrix product unitary approach and higher dimensional classifications.


Introduction
Cellular automata (CAs) are fascinating systems: despite having extremely simple dynamics, we often see the emergence of highly complex behaviour. CAs were first introduced by von Neumann [1,2], who wanted to find a model that was universal for computation and could in some sense replicate itself [3]. Building on a suggestion by Ulam, von Neumann considered systems with discrete variables on a two-dimensional lattice evolving over discrete timesteps via a local update rule. Von Neumann's program would eventually be successful, as CAs exist that can efficiently simulate Turing machines and display self replication. An example of a CA where this can be seen is Conway's game of life [4], which also involves a two-dimensional lattice of bits. There one sees remarkable patterns and dynamics, and it indeed includes configurations that can self replicate.
In general a cellular automaton is a d-dimensional lattice of bits (or a more general finite set of variables) that updates over discrete timesteps. The update rule is the same everywhere and updates a bit based only on its state and those of its neighbours. An important example of a cellular automaton is known as the rule 110 CA. In this case, we have a one-dimensional array of bits, and the updated state of each bit after one timestep depends on its previous state and that of its two nearest neighbours. The update rule is best summarized by the table below.
Initial state of a bit and its neighbours 111 110  The name comes from the result of the update rule [5]. Treating 01101110, which is the bottom row of the table above specifying the update rule, as binary and converting to decimal gives 110. This CA can simulate a Turing machine [6], and it was shown later that this can even be done efficiently (with only polynomial overhead) [7]. It would turn out that CAs have many practical applications, which include traffic models, fluid flows, biological pattern formation and reaction-diffusion systems [8]. A special case of CAs are lattice gas cellular automata, which were used to model fluid dynamics, and indeed, with the right choice of model, one recovers the Navier-Stokes equation [9,10]. These have been replaced by lattice Boltzmann models [9,10], which use continuous functions instead of discrete variables at the lattice sites. More ambitiously, CAs have been put forward as discrete models of physics [11], having many desirable properties, such as locality and homogeneity of the dynamics. But, while this is a tempting idea, physics is fundamentally quantum, and CAs cannot correctly describe, e.g., Bell inequality violation, which results from quantum entanglement. 1 Quantum cellular automata (QCAs) are the quantum version of CAs. The initial rough idea can be traced back at least as far as [12], where it was proposed that to simulate quantum physics it makes sense to consider quantum computers as opposed to classical. Indeed, it is a widely held belief that quantum simulations of physics will probably be the first application of a quantum computer [13]. Initial specific models for QCAs were then given in, e.g., [14,15]. In [15] QCAs were introduced as an alternative paradigm for quantum computation and were shown to be universal, meaning they could efficiently simulate a quantum Turing machine. In the earlier paper [14], a model of quantum computation was given that could be described as a classically controlled QCA, meaning that over each discrete timestep we have a choice of global translationally invariant unitaries to apply. The proposal suggested applying homogeneous electric fields of different frequencies to a one-dimensional chain of systems (e.g., a row of molecules), and it was argued that this would be a realizable model of quantum computation. A potential benefit of this type of quantum computation is that it involves homogeneous global operations on all qudits, in contrast to the circuit model, where single or few qubit addressability is essential, and this is sometimes difficult in, e.g., trapped ions.
Perhaps surprisingly, the route from CAs to QCAs was not so straightforward. Various roadblocks arose, and naive approaches, such as simply extending the classical evolution by linearity to get something quantum, do not always work. Another problem is that in CAs each cell can be updated simultaneously, but we may need to copy the original state of a cell, so that we can update its neighbours after it has been updated. This is impossible in the quantum setting because of the nocloning theorem [16,17]. To get around many of these problems, there were various constructive approaches, typically defining QCAs as layers of finite-depth circuits, possibly in combination with shifting some qudits left or right. It was only later that an axiomatic definition of QCAs was given, which captured the spirit of CAs, while ensuring that the dynamics were quantum [18]. It was not initially clear how useful this definition was in dimensions greater than one, at least until it was shown in [19] that any QCA defined in this axiomatic way can be written as a local finite-depth circuit by appending local ancillas. With this it seems that a sensible definition of QCAs has been found, and any of the constructive approaches satisfy it. Essentially, the axiomatic definition (which we will use) of a QCA is that it comprises a spatial lattice with quantum systems at each site, and it evolves over discrete timesteps via a unitary 2 that is locality preserving. Locality preservation is the discrete analogue of relativistic causality, which means that in the Heisenberg picture local operators get mapped to local operators. We will go into more detail about all this in section 2.
One ambitious application of QCAs is as discrete models of physics. In fact, once spacetime is taken to be discrete, and a maximum speed of propagation of information is assumed, assuming unitarity leaves us with a QCA. In contrast, it is clear that continuous-time dynamics via a local Hamiltonian on a lattice will not suffice, as there is no strict upper bound on information propagation (see section 6.1). Whether or not physics can truly be discretized is a nontrivial and interesting question in its own right [20]. And while roadblocks such as fermion doubling may arise and would still have to be dealt with, QCAs have nevertheless been proposed as an interesting class of discrete models of physics [11].
In a more specific setting, QCAs have been considered as discretized quantum field theories, i.e., as an alternative regularization of quantum field theory. They have a couple of nice properties in this regard: they have a strict upper bound on the speed of propagation of information and the lattice provides a cutoff, which allows us to regulate the infinities that need to be handled carefully in quantum field theory. At the moment however, it seems unlikely that QCAs can offer any advant-ages for performing calculations in comparison with, e.g., dimensional regularization. Still, we may be interested in QCA discretizations of quantum field theory for simulating physics on a quantum computer. This is more promising, and it may offer a new perspective on quantum simulations of quantum field theory. Indeed, much progress was made in understanding quantum field theory in the 70s by Wilson, who was trying to understand how to simulate QFT on a classical computer [21].
Recently, in condensed matter physics, QCAs have been proposed as models for quantum lattice systems evolving via time-dependent periodic Hamiltonians (i.e., Floquet systems). Typically, such systems do not quite fulfil the locality preserving component of the definition of a QCA, but because of Lieb-Robinson bounds [22], they do approximately. In this context, QCA techniques have been useful for classifying chiral phases of Floquet systems [23,24]. The key to this is the index theory for one-dimensional QCAs, which allows one to assign a number to one-dimensional QCAs quantifying the net information flow along the chain. And crucially this number is robust against perturbations. By applying the index theory to the boundary dynamics of two-dimensional Floquet systems with many-body localization, we get a classification of different dynamical phases given by the index of the boundary theory.
There are a handful of older reviews of QCAs available [25][26][27], and a key reference that provides a thorough discussion of QCAs up to 2004 is [18]. There are also a couple of theses on QCAs, which offer good reviews of specific aspects of the subject as well as some novel insights; see, e.g., [28][29][30][31][32]. Since these were written, many new results have appeared, so the time is ripe for an up-to-date treatment of the topic. Coincidentally, another review was written at the same time as this one [33], which is quite complementary to this one, as it has a detailed discussion of intrinsic universality, a topic that is mentioned only briefly here in section 4.2.

Two examples of QCAs
Let us look at two simple examples of QCAs that not only provide us with some intuition but also arise as components of most constructions of QCAs. Before we start, note that, for continuous-time systems the dynamics is determined by the Schrödinger equation, but we are going to work with discrete-time systems, so there is no Schrödinger equation. Instead, we work directly with the unitary operator that evolves the system every timestep. Take a discrete ring of qubits with position label n ∈ {0, ..., N − 1}, where N is even and we have periodic boundary conditions, so we identify sites N and 0. Consider applying a depth-two circuit of unitaries as in figure 2. Let V 2n,2n+1 be a unitary acting non trivially on qubits 2n and 2n + 1 only. This means that it acts like the identity on all other qubits. Similarly, let W 2n−1,2n be a unitary acting on qubits 2n − 1 and 2n. Consider the unitary circuit Here, the ordering inside the products is unimportant because, e.g., V 2n,2n+1 and V 2k,2k+1 commute for all n, k. As an example, let V n,n+1 = W n,n+1 = C n [X n+1 ], which is the controlled-NOT unitary, familiar from quantum computing [16]. Here n labels the control qubit and n + 1 labels the target qubit. Explicitly, where X n+1 denotes the Pauli X operator on site n + 1. For completeness, the Pauli operators in the computational basis are To see that the unitary U takes local operators to local operators, it suffices to check that, for any Pauli operator (e.g., X n ) localized on site n, u(X n ) = U † X n U is localized on nearby sites. While such constant-depth circuits form an important class of QCAs, we will see in section 5.2 that there are QCAs that cannot be expressed in this form. The quintessential example of this is a shift, which simply shifts each subsystem one step to the right as in figure 3. For qudits, the dynamics is given by s(A n ) = S † A n S = A n−1 , where A n is any operator on qudit n, and S is the unitary implementing the shift. This describes a shift of the qudits by one step to the right, and the fact that A n gets mapped to A n−1 is because we are working in the Heisenberg picture. Using the Heisenberg picture makes it easier to define what it means for the evolution to be locality preserving: one simply requires that the operators only spread a finite distance from where they started. We will discuss this further in section 2. This second example of a QCA is simple yet surprisingly important. It will play a major role in many of the discussions to come.

Things that are not QCAs
It is a little confusing that the name quantum cellular automata or other similar sounding names have been used for several unrelated concepts, so it will help to go through what we do not mean by QCAs in this review.
One example of this occurs in [34], where the systems studied are called unitary cellular automata. These are actually single-particle systems, and these would be called discrete-time quantum walks according to current terminology (see, e.g., [35,36]). Similarly, other works from this period refer to discrete-time quantum walks as quantum cellular automata or unitary cellular automata, e.g., [37][38][39]. In fact, we can often view these discrete-time quantum walks as the dynamics of the one-particle sector of a QCA [18,30], which is something we will return to in section 6.3.
Another potential source of confusion are quantum dot cellular automata, which were first introduced in [40,41]. These were originally referred to as quantum cellular automata, and, while the name quantum dot cellular automata seems to have become popular, the abbreviation QCA is often used for these. Quantum dot cellular automata are a new paradigm for implementing classical computing using quantum dots instead of conventional semiconductor-based integrated circuits. However, a proposal has also been made to use such an array of quantum dots to implement a quantum computer [42], though the idea here is to use the circuit model of quantum computation, which typically uses many different few-qubit gates as opposed to uniform global operations. This particular quantum dot architecture is referred to in [42] as a coherent quantum dot cellular automata.
Another similar-sounding but different model are continuous-time quantum cellular automata [43]. These also go by the name Hamiltonian QCAs [44] or continuous cellular automata [45]. These do not fit our definition of quantum cellular automata because they evolve via Hamiltonians in continuous time, though they are an interesting model of quantum computation.
QCAs are also not to be confused with attempts to replace quantum mechanics by classical cellular automata [46], which is referred to as the cellular automaton interpretation of quantum mechanics. It is worth mentioning that this proposal considers classical cellular automata, which are obviously not quantum, and therefore cannot reproduce the correlations due to quantum entanglement without, e.g., correlated measurement choices. Describing physics (and specifically quantum physics) by classical cellular automata was also proposed in [47], though this also has problems in describing entanglement [48].

Definition
There had been many different proposals for a concrete definition of QCAs, but the theory was put on a sound mathematical footing in [18,49]. It is worth highlighting that any of the previous proposals for a definition of a QCA (when they make sense, i.e., they involve locality-preserving unitaries or automorphisms), such as local unitary QCAs [50], satisfy the definition we give here.
As stated in section 1, defining QCAs is nontrivial, and naive quantization of CAs [51] can oddly lead to faster-than-classical signalling [52].

Systems
QCAs are defined on quantum lattice systems, meaning we have a discrete spatial lattice Γ with quantum systems at each lattice site (or cell). Some authors consider more general graphs, e.g., [19], but we will stick with lattices here. The lattices we consider may be infinite, i.e., Z d , or finite, possibly with periodic boundary conditions.
As an aside, an alternative possibility to just fixing a lattice, described in [53], involves control spaces. In that case, we consider families of QCAs with sites that are points in a control space, which is some metric space. For example, the control space could be torus, and the family of QCAs could correspond to finer and finer finite grids of points taken from the torus.
We will take the quantum systems at each lattice site to either be finite-dimensional quantum systems, i.e., qudits, or we take them to be a finite number of fermion modes. 3 After all, since QCAs are the quantum generalization of CAs, it makes sense to not just admit qudits but also other nonclassical systems arising in quantum physics, such as fermions. We will not deal with truly bosonic systems here, i.e., those having infinite-dimensional Hilbert spaces at each lattice site with the usual bosonic creation and annihilation operators. However, QCAs of continuous variable systems were considered in [55]. These were a specific class of QCAs, called Gaussian QCAs, which evolve via Gaussian operations, i.e., those taking Gaussian states to Gaussian states. This restriction makes the dynamics tractable. Similar restrictions for finite dimensional systems at each site give rise to Clifford QCAs, which we discuss in more detail in section 3.1.
For finite lattice systems, the total Hilbert space is just the tensor product of the Hilbert spaces corresponding to each lattice site. Each lattice site n has a finite-dimensional quantum system with Hilbert space H n , so the total Hilbert space is H = ⊗ n∈Γ H n . Instead of Hilbert spaces, it will be easier for us to work with the algebra of observables. We denote the algebra of observables acting on the system at site n by A n , which is isomorphic to M d n , the algebra of d n × d n complex matrices. The total observable algebra is then A = ⊗ n∈Γ A n . Given a subset of the lattice R ⊂ Γ, we define A R to be the operators localized on region R, meaning they act like the identity on all sites outside of R.
For infinite lattices of qudits, it does not make sense to simply take the infinite tensor product of the Hilbert spaces or algebras. This is because we cannot make sense of, e.g., the inner product of |0 ⊗N and (i|0 ) ⊗N as N → ∞. There are a couple of ways around this: most notably, either we restrict the observables we allow (the quasi-local algebra approach), or we restrict the states we allow (the finite-unbounded configurations approach). From a physical perspective, the former is more satisfying: we can only do local operations in a lab, so it makes sense to rule out something like σ ⊗∞ z as an observable. For this reason, the choice we make is the quasi-local algebra approach. We will explain why this is the more general approach anyway (a QCA on finite-unbounded configurations is always a representation of a QCA on a quasi-local algebra) in section 2.4.
In fact, very little of the formal theory of quasi-local algebras is actually needed, just some of the basics. It may also be reassuring to note that for QCAs it is usually possible to just restrict our attention to a finite but sufficiently large lattice anyway. This is because the dynamics is strictly locality-preserving, as we discuss in the following section. For this reason, everything that follows can be understood by considering finite lattices. Nevertheless, it is also interesting to consider the infinite case, as the quasi-local algebra construction is rather elegant, and allows one to employ ideas from the statistical mechanics of infinite systems [49].
For infinite lattices, we also denote the algebra describing the system at site n on the lattice by A n , which is isomorphic to M d n . And more generally, for every finite lattice region R, there is an associated algebra A R isomorphic to ⊗ n∈R A n . Such algebras contain the local elements, which act nontrivially on systems only in region R and like the identity on the rest of the lattice. The algebra corresponding to a subregion R ⊂ R is identified with the subalgebra of A R acting nontrivially only on sites in R . The algebra for the whole system is defined to be where the line above denotes closure in the norm. 4 In other words, the algebra includes elements defined by Cauchy sequences of local elements, hence the name quasi-local algebra. For finite lattices, states are just density matrices, whereas in the infinite case, states are assignments of density matrices to each finite region, with a consistency requirement: given density matrices ρ R and ρ R on R and R respectively, with R ⊂ R, we require that tr R\R [ρ R ] = ρ R . (More formally, we could instead start by defining states as linear functionals of the algebra ω, with the constraints ω(1 1) = 1 and ω(A) ≥ 0 for all positive A ∈ A, meaning A = B † B for some B ∈ A.) We introduce some more of the formalism of C * -algebras in appendix A. A nice introduction to quasi-local algebras can also be found in [56], and for more detail there is also the two-volume classic standard reference [57].

Dynamics
As mentioned earlier, to describe the dynamics of QCAs, it is usually preferable to work in the Heisenberg picture, with observables evolving in time. This makes it much easier to define and understand a key feature of the dynamics: locality preservation. 5 Of course, it is sometimes useful to switch to the Schrödinger picture, as we will in some cases, since it is simpler for, e.g., seeing the connection to quantum computation.
So over each timestep the QCA evolves via a unitary operator in the finite case or an automorphism of the algebra in the infinite case. We denote the dynamics of a QCA by u : A → u(A), for any A ∈ A. Automorphisms are the natural generalization of unitaries to infinite systems, since they satisfy all the desired properties of unitary maps: they preserve, e.g., commutation relations. However, there need not be any element of the algebra U ∈ A that implements this transformation via u(A) = U † AU . In contrast, for finite lattices, there is always such a unitary U . We will often write the evolution as u(A) and speak of automorphisms, though these can be replaced by U † AU and unitaries respectively for finite systems. Note that u(AB) = u(A)u(B) always, so it is enough to understand how single-site algebras evolve to understand the whole evolution. Figure 4: A unitary or automorphism is locality preserving if it maps local operators to local operators (in the Heisenberg picture). At t = 0 an operator A is localized on four sites, but after one timestep the updated operator u(A) is localized on nine sites nearby.
We also demand that the evolution is locality preserving (see figure 4). This means that local operators get mapped to operators localized on a region nearby. Sometimes the locality preserving property is called causality (e.g., in [19,58]) in analogy with relativistic causality. More precisely, the dynamics is locality preserving if there is some l ≥ 0 such that, for any n and any operator A localized on n, then u(A) is localized on a region consisting only of sites m with | n − m| ≤ l. Here we use the Taxicab metric on the lattice. We may also define the neighbourhood of a point n, which we denote N ( n). Then N ( n) is the smallest region on which the algebra u(A n ) is localized. We can generalize this to describe the neighbourhood of a region R, denoted by N (R).
We will not always assume that QCAs are translationally invariant, though this was traditionally assumed in many works. Sometimes we will restrict to this case, as further interesting results follow. It would be more in the spirit of classical CAs, to always consider translationally invariant dynamics, but some of the most interesting QCA structure theorems do not require any form of translational invariance (see section 5). As an aside, it would also be interesting to consider irreversible QCAs, as in [17,49], though not much work has been done in this direction. In this case, e.g., unitaries would be replaced by completely positive trace-preserving maps.
We conclude the section with a summary of the definition of a QCA.
Definition 2.2.1. A QCA consists of a discrete hypercubic lattice, which may be finite or be Z d , with a finite quantum system at each site (qudits and/or fermion modes). Evolution takes place over discrete timesteps via a locality-preserving automorphism (or unitary for finite systems).

Global and local transition rules
As we saw in section 1, in the classical setting, CAs are usually defined by a local transition rule. This tells us how, e.g., the bit at site n updates its state depending only on the states of its immediate neighbours. In the previous subsection, however, we defined QCAs by a global transition rule-an automorphism or unitary of the observable algebra that preserves locality. However, we may also specify a QCA by local transition rules [18]. To go from a global rule to local rules, we define the local transition rules to be the maps α n : A n → A N ( n) such that This α n tells us how observables localized on n spread out in N ( n). (In the translationally invariant case, it is enough to specify α 0 .) To get something closer to the local rules of classical CAs, we could then switch to the Schrödinger picture, though this description will be quite cumbersome. In equation (6), we simply defined the local rule by using the global rule, so it is obvious that we get a sensible QCA and that the global dynamics uniquely specifies the local transition rules. On the other hand, going the opposite direction is more interesting: we may start with some candidate for a local rule, some β n taking A n to A N ( n) for every n. Then we define a candidate for a global rule v to be linear, and to act on products of operators at different sites via, e.g., if A and B are elements from A n and A m respectively. Starting from such a local rule, the question is whether this candidate is a bona fide QCA? For example, our rule may not be a valid automorphism; it may not even be invertible. First, we need that β n is an isomorphism, so it preserves the algebraic structure locally, mapping A n to an isomorphic subalgebra of A N ( n) for every n (something like β n (A) = 0 for all A will obviously not do). The only other condition we need is that, for any n = m, and any A ∈ A n and B ∈ A m , [β n (A), β m (B)] = 0, which is enough to guarantee that the map defines an automorphism. This was proved in [18] for one-dimensional translationally invariant QCAs of qudits in [18], but the proofs carry over straightforwardly to non-translationally invariant and higher dimensional systems.
For non-translationally invariant QCAs, checking that equation (8) holds will usually be impossible, as we cannot check an infinite number of conditions in practice. On the other hand, for translationally invariant systems, because the neighbourhoods are finite, we need only check that [β 0 (A), β m (B)] = 0, for all A ∈ A 0 and B ∈ A n , when the neighbourhoods of 0 and n overlap, i.e., N ( 0) ∩ N ( n) = ∅. And we need only check this for a basis of elements of A 0 and A n for each n with N ( 0) ∩ N ( n) = ∅. This means that only a finite number of commutators need to be computed, making it feasible to check if a local rule indeed gives a legitimate QCA.
In the translationally invariant case, there is also a natural correspondence between QCAs on infinite lattices and QCAs on finite lattices, which works because the dynamics is locality preserving. This is called the wrapping lemma [18]. This means that any translationally invariant QCA on an infinite lattice is in one-to-one correspondence with a QCA on any finite lattice with periodic boundary conditions (and the same dimension), provided the finite lattice is big enough that the overlaps of the neighbourhoods of two sites are the same as for the infinite case. This was recently generalized to fermions in [59].

Finite, unbounded configurations
An alternative way to deal with infinite systems and infinite tensor products (as opposed to the quasi-local algebra approach we use here) constructs a Hilbert space called the Hilbert space of finite, unbounded configurations. This is used, for example, in [60]. As we will see, this is covered by our definition, as these are always representations of a subset of QCAs defined in our sense.
The idea of the finite, unbounded configurations approach is to restrict the possible states the system can be in. We start by assuming that each lattice site can be in one of a finite number of states, and one of these states is a privileged state, called a quiescent state q. We allow all configurations of the system where only a finite number of sites are not in the quiescent state, e.g., infinite strings like ...q q q a b c q q q... for a one-dimensional system. Then we use these strings to label an orthonormal basis of a complex vector space. To get a Hilbert space, we complete the vector space in the inner-product norm. This Hilbert space is separable (i.e., it has a countable basis) and is sometimes called an incomplete infinite tensor product space. This is the Hilbert space of finite, unbounded configurations.
Notice that this Hilbert space admits all operators corresponding to the quasi-local algebra of the system: we can perform any local operation we like, as this will only change the state in some finite region and will keep us in the Hilbert space of finite, unbounded configurations. Next we define the dynamics to be determined by a locality-preserving unitary U on this Hilbert space. (We use the exact same notion of locality preserving as before in this setting, working in the Heisenberg picture.) Requiring that U is unitary, translationally invariant, and locality preserving means that U must preserve the state |...qqqqq... . The advantage of this formalism is that we can work with Hilbert spaces and unitaries, instead of algebras and automorphisms. The disadvantage is that we exclude many interesting states and dynamics on the system (a workaround should be possible by increasing the local dimension in the finite, unbounded configurations setting). For example, the unitary must always have the product state |...qqqqq... as a +1 eigenvector.
Instead of constructing the Hilbert space of finite, unbounded configurations and QCAs on them in this way, we can construct them as a representation of a QCA defined in the quasi-local algebra setting. (See [61] for a similar construction in the translationally invariant case.) Suppose we have a QCA with dynamics u, and let ω be some invariant state, so ω(u(A)) = ω(A) for all A ∈ A. Here we are writing the expectation value of A in state ω as ω(A) (for finite systems, this would be tr[ρA] for some density operator ρ). We can always construct a representation of the algebra where the state ω is represented in the resulting Hilbert space H by a normalized vector |ω , with the representation of any operator A being denoted π(A). (This uses the GNS representation of the algebra, which is described in appendix A.) Furthermore, because u leaves the state ω invariant, there is a unique unitary U that implements the dynamics in the representation, i.e., U † π(A)U = π(u(A)) and U |ω = |ω (see appendix A and [57]). To connect with the finite, unbounded configurations approach, let us suppose that ω is a pure product state. Then the representation π(A) is irreducible. We can construct an orthonormal basis for H by applying local operators π(A) to |ω , and because the Hilbert space must be complete, we get exactly the Hilbert space of finite, unbounded configurations. As an example with qubits on a line, we could choose ω to be the 0 state of all the qubits. In the representation, we would have |ω = |0...000...0 . Then, for example, the action of the Pauli X operator at site n is given by π(X n )|0...000...0 = |0...010...0 . An example of a QCA dynamics leaving ω invariant is the CNOT QCA in section 1.1.
We should emphasize that any QCA defined in the finite, unbounded configuration picture can be expressed in our formalism, as an automorphism on the quasi-local algebra. This follows because the unitary implementing the dynamics for a finite, unbounded configuration also defines an automorphism of the algebra of local operators that is locality-preserving and hence uniquely defines dynamics for a QCA in the quasi-local algebra picture. So the finite, unbounded configurations QCAs can be viewed as special cases of our notion of QCAs. But for some applications, it is useful and intuitive to use the finite, unbounded configurations picture.
To see that there are QCAs that cannot be expressed in terms of a Hilbert space of finite, unbounded configurations (at least without adding local ancillas), consider that a translationally invariant QCA need not have any invariant pure product state, something which we would actually expect to be the case in general. If this is the case, then it is not directly representable in the finite, unbounded configuration picture. As quantum field theories, for example, have highly entangled vacua [62], it seems clear that any ideas for discretizing such models with QCAs would not be naively representable by finite, unbounded configurations.
The finite, unbounded configurations approach to QCAs was used as a definition of a Schrödinger template of a QCA in [61]. This can easily be generalized by constructing a representation of the quasi-local algebra and dynamics using any invariant state (not necessarily a product state) of the automorphism as described above. Then one has a picture of the QCA with a Hilbert space of states and dynamics represented by a unitary. Indeed, it seems reasonable to view the invariant state in that case as a vacuum state and to think of the resulting Hilbert space as the space of localized excitations above the vacuum state. From that point of view, it would make sense to call the resulting Hilbert space the Hilbert space of finite, unbounded excitations. And so we could interpret the main result of [61] as characterizing when a QCA admits a representation in terms of finite, unbounded configurations with an invariant product state.

More examples of QCAs
There are several different specialized classes of QCAs that fit into our framework. We will look at two below. The first class of QCAs that we will discuss are Clifford QCAs. In this case, we restrict to dynamics that map strings of Pauli operators to strings of Pauli operators. This restriction makes this class of QCAs tractable. The second class of QCAs involve concatenating shifts and local unitary circuits. These typically involve some kind of partitioning scheme for the lattice, and are constructive by their definition (in contrast to Clifford QCAs, which are defined by a constraint on their dynamics). Such QCAs have been particularly important, as they are manifestly unitary and have been used to show universality of QCAs for quantum computation [15]. Some discussions of the different models can also be found in [18,43,63].

Clifford QCAs
An important class of QCAs are Clifford QCAs [18]. These are translationally invariant QCAs defined on a lattice of qubits, where the dynamics is a Clifford operation, which means it takes any string of Pauli operators to a multiple of a string of Pauli operators. (We comment on the generalization to qudits below.) Such operations are classically simulatable, so Clifford QCAs cannot be universal for quantum computation (except in the unlikely event that quantum computers can be classically simulated). Nevertheless, they have interesting properties, and provide a nice playground to get some intuition about QCA dynamics. Here we will consider only one-dimensional translationally invariant Clifford QCAs. While the definition makes sense if one goes beyond this case, higher dimensional Clifford QCAs have not been given as much attention.
Let us look at an example of a Clifford QCA from [18]. The dynamics are determined by the automorphism u l acting as for a fixed l ∈ Z. Notice that this already determines the dynamics completely because u l (AB) = u l (A)u l (B) and u l is linear. For example, with l = 1 and writing u = u 1 , we can easily calculate where the last line follows from equation (9). The Clifford constraint is quite strong, and as a result to understand the dynamics we need only look at a CA. Let us see how this works for the example above. We can represent Pauli products by strings of integers. We label 1 1, X, Y, Z by 0, 1, 2, 3 respectively. Given an initial string of Paulis, we represent it by a string µ m , where µ m ∈ {0, 1, 2, 3} for each m ∈ Z. To find out the value of the string at position m = 0 after one timestep we need only know µ −1 , µ 0 and µ 1 . Suppose, e.g., we have (..., µ −1 , µ 0 , µ 1 , ...) = (..., 2, 1, 2, ...), which represents an operator that has the form ..,−2} and B {2,...,∞} are some products of Paulis on the rest of the qubits. After one timestep we have by using equation (9) .., ∞} respectively. Thus, we get µ 0 = 3 after the update. By finding µ 0 for all possible products of Paulis on the sites −1, 0, 1, we infer the corresponding CA rule. In this case, the CA consists of a discrete line of cells where each cell has four possible states in 0, 1, 2, 3, and the update rule for a site depends only on its nearest neighbours. Note that we disregard the overall phase: a Clifford operation could map, e.g., X n to −X n , but we ignore this. This CA description is enough to tell us how strings of Paulis spread out. An example of the dynamics of the ensuing CA is shown in figure 5. In [64,65], far more sophisticated methods are used for studying Clifford QCAs, but we can already understand a lot of the structure by deriving CAs for the evolution of Pauli strings as we have done here.
Remarkably, the QCAs in equation (9) for different values of l, together with on-site Clifford operations and the shift generate all possible translationally invariant Clifford QCAs in one dimension [64]. Figure 5: An example of Clifford QCA dynamics with update rule fully specified by X n → X n−1 ⊗ Y n ⊗ X n+1 and Z n → X n . Each square represents an element in a Pauli string: white represents 1 1, X is yellow, Y is blue and Z is green. Notice the fractal structure in the spacetime diagram (where time goes up).
Furthermore, Clifford QCAs on a line can be classified into three classes [65,66]. There are those with gliders, which are observables that simply move along the line each timestep; there are periodic Clifford QCA, which are periodic in time; and there are fractal Clifford QCA, which are self similar on large scales of a spacetime diagram, an example of which can be seen in figure 5. The QCA in equation (9) with l = 1 has examples of gliders. Consider the observable X 0 ⊗ Z 1 . After one timestep, this is mapped to u(X 0 ⊗ Z 1 ) = X 1 ⊗ Z 2 , so it is just translated to the right. Similarly, Z 0 ⊗ X 1 gets translated to the left by the QCA. The fractal structure in spacetime plots of fractal Clifford QCAs was studied in further detail in [66,67]. This was made possible by analysing the resulting fractal structures in the corresponding CAs.
Additionally, entanglement generation in Clifford QCAs was studied in [65,66]. In [64], it was also shown that every unique translationally invariant stabilizer state in one dimension can be generated by the action of a Clifford QCA acting on a product state. More recently, the eigenstates of Clifford QCAs have been analysed in [68], where it was seen that the eigenstate thermalization hypothesis does not apply to these models. The eigenstate thermalization hypothesis is the hypothesis that, when we look at the reduced state of an energy eigenstate on a small subsystem, we approximately get a thermal state with a temperature that does not vary too quickly with the energy of the eigenstate. (There are a few different versions of the eigenstate thermalization hypothesis, and this is just one of them.) On the one hand, it may not be so surprising that Clifford QCAs, which are discrete-time systems with a lot of structure, do not satisfy the eigenstate thermalization hypothesis. But on the other hand, there is evidence that periodically driven Hamiltonian systems satisfy the hypothesis [69], and QCAs are a useful approximate model for such systems, something we will discuss further in section 6.1.
As we just saw, the constraint that the evolution is a Clifford operation is quite powerful, and the simplification arising from this constraint can be generalized [64]: one can go beyond qubits and Pauli operators, instead looking at p dimensional qudits and discrete Weyl operators, provided p is prime. Fixing an orthonormal basis for such a qudit to be |q , with q ∈ {0, ..., p − 1}, then the Weyl operators, which generalize X and Z, are defined by where the addition in the first line is defined modulo p. Again we have the constraint that products of Weyl operators, e.g., X n ⊗ Z n+1 get mapped to products of Weyl operators. Many of the results for qubit systems extend to these systems, though at the cost of being a bit more complicated [64]. It is interesting that such constraints on the dynamics make the systems tractable. Instead of the Clifford constraint, we could just restrict the QCA neighbourhood and the dimension of the systems at each site. This was done in [18], where it was shown that nearest-neighbour qubit QCAs are always decomposable in terms of shifts, on-site unitaries and controlled phase gates.

Partitioning schemes
In section 1.1 we saw two examples of QCAs: constant-depth circuits and shifts. These basic building blocks can be combined to get various different classes of QCAs that appear in the literature. Figure 6: To define QCAs dynamics it is often useful to partition the lattice into supercells by grouping sites together. (The supercells can have any shape as long as they are finite.) Then we apply unitaries to each system in the supercells. More generally we consider several different partitions and apply different unitaries to supercells in each partition in sequence to implement the QCA dynamics.
As a first step, we can generalize the finite-depth circuit construction from section 1.1 in the following way. Consider partitioning the lattice into supercells C 1 n , with n ∈ Z d , in such a way that each cell on the lattice is contained in exactly one supercell (see figure 6). Then one can construct a QCA by applying a depth-one circuit of unitaries U 1 n , where U 1 n is localized on C 1 n , i.e., the system evolves via where the order in the products does not matter because the unitaries act on non-overlapping regions and hence commute. On its own this is not so interesting because the systems inside different supercells do not interact. Instead, we consider P different partitions of the lattice, C p n , where p ∈ {1, ..., P }, and different unitaries U p n for each supercell in each partition. Then the dynamics is given by where each u p is defined analogously to equation (13) with unitaries U p n is localized on C p n .
As an example of QCAs using such a partitioning scheme, let us look at the block-partitioned QCAs defined in [17], which use layers of conditional unitaries. In the nearest-neighbour case with qubits on a one-dimensional system, we define the operator (acting nontrivially on sites n − 1, n and n + 1 only) where a, b ∈ {0, 1} and v ab n is a unitary on site n. Then we can define the conditional unitary operator If the qubits n + 1 and n − 1 are in, e.g., the 0 state, this implements the unitary v 00 on qubit n. The QCA dynamics is then given by a depth-two circuit: first we apply V n to all cells at even positions, then to all cells at odd positions, i.e., The properties of these QCAs were studied in [17], where information transport along the chain and entanglement generation were studied. This partitioning scheme also makes the construction of non-unitary QCAs straightforward [17], by replacing the local unitaries by local completely positive trace-preserving maps. This allows one to construct an irreversible QCA that gives a quantum version of the classical rule 110 CA from section 1. To see that we need a non-unitary QCA to do this, notice that rule 110 itself is irreversible. This can be seen by considering the state with 0 everywhere and the state with 1 everywhere. After one timestep, these both get mapped to the same state. We can also generalize the shift along a line to shifts along lattice directions for higher dimensional systems. Suppose the lattice has lattice basis vectors e i where i ∈ 1, ..., d, then we define the shift along lattice direction e i by which has no other effect than to shift the algebra by one step in the direction e i . We may also consider partial shifts. These would just shift a subalgebra instead of the whole algebra. One useful example involves a one-dimensional lattice with qudits at each site. Then we divide the cells into three subcells, which we label by l, c and r. So we may write A n = B l n ⊗ B c n ⊗ B r n . Then we define the conditional shift σ to be This particular conditional shift (we could define more general versions, particularly in higher lattice dimensions) is useful for constructing the partitioned QCAs in [15,28], which are usually referred to as Watrous partitioned QCAs. After applying σ, we may also apply an automorphism λ that is just a product of on-site unitaries. The overall dynamics is as illustrated in figure 7. It is easy to see then that the dynamics is an automorphism. Interestingly, this is a special case of quantum lattice gas automata, which we will return to in section 6.3.1. These comprise partial shifts (which are interpreted as propagating different particle types on the lattice) and on-site unitaries (which model interactions between particles). Other examples of QCAs defined via partitioning schemes arise in the literature, e.g., local unitary QCAs [50]. As an aside, it is worth pointing out that many of these partitioning schemes were initially introduced in the framework of finite, unbounded configurations, but they also fit perfectly well into our framework.

QCAs as quantum computers
QCAs were originally envisaged as a model of quantum computation, useful for simulating physics or implementing more general quantum algorithms. One of the earliest breakthroughs in this regard was the proof that QCAs can efficiently simulate quantum Turing machines with only constant slowdown [15]. The proof used the Watrous partitioned QCAs of the previous section.
If we consider instead the circuit model of quantum computation, it is clear from a result that we will see in section 5.1 that the circuit model can efficiently simulate any QCA. 6 And we know that the converse is true because we can use a QCA to simulate a quantum Turing machine, which can then simulate the circuit model. Nevertheless, it will be interesting to look at an explicit example in the following section where we directly simulate a quantum circuit with a QCA. Note that we only consider translationally invariant QCAs in this section. (Relaxing this constraint would make the results trivial. Besides, the main appeal of quantum computation via QCAs is that ideally one need only apply global operations without worrying about implementing many different single-or few-qubit operations. This advantage may be lost in the translationally non-invariant case.)

A QCA efficiently simulating quantum circuits
Let us look at a prescription from [71] for simulating quantum circuits using a translationally invariant QCA. The QCA system is a two-dimensional discrete torus (i.e., a two-dimensional lattice with periodic boundary conditions), and the program itself, as well as the input data for the algorithm, are encoded in the initial state of the QCA. In this section it will be more convenient to work in the Schrödinger picture.
We label the sites of the torus with coordinates n ∈ {0, ..., 2s − 1} × {0, ..., 2r − 1}, and each site has a single qubit. We label columns on the torus by the second component of n, which ranges from 0 to 2r − 1. The qubits in the odd-numbered columns will encode what gates we wish to implement. So for the purposes of the algorithm, these qubits will always be in one of the the two computational basis states |0 and |1 . The qubits on the even-numbered columns will encode the data that our quantum circuit is to act upon. In particular, at time t = 0 column 0 has the initial input data for the quantum algorithm. We will use the supercell partitioning scheme of section 3.2, with two simple partitions of the torus, but we will consider the application of the unitaries to both partitions to correspond to two timesteps, meaning the evolution is different for even and odd timesteps. The partitions are as shown in figure 8 (a). The first consists of 2 × 2 squares of cells with the cell in the top left corner having both coordinates even, e.g., n = (0, 0). The second consists of 2 × 2 squares of cells but now with the cell in the top left corner having both coordinates odd, e.g., n = (1, 1). So the supercells in the first partition are labelled by vectors with both components even, and those in the second partition are labelled by vectors with both components odd.
Next we define the unitaries that act on these supercells, which all have the same form: where S n just swaps the states of the two left qubits in the square with the two qubits on the right. This part of the gate swaps the data qubits with the program qubits after applying W n . To make the notation simple, label the four sites as in figure 8 (b). For W we take Let us go through each of the components on the right hand side. Two of these unitaries are controlled by the program qubits: C 3 [U 1 ] and C 4 [R 12 ] are unitaries applied to data qubits controlled by the program qubits 3 and 4. So if, e.g., qubit 3 is in the |1 state, the unitary U 1 is applied to qubit 1, and if it is in the |0 state, the identity is applied. H 1 is the Hadamard gate applied to qubit 1, i.e., The choice made in [71] for the gates U 1 and R 12 is so R 12 is simply a Pauli Z operator on qubit 2 controlled on qubit 1. (These are both data qubits.) The evolution at even and odd timesteps is then given by the products where the product in the first/second line is over all n with both entries even/odd. Now consider the initial state Here |D i (0) 2i is the state of the data qubits in column 2i. And |P i+1 2i+1 is the state of the qubits in column 2i + 1, which encode the program, i.e., the unitaries that should be implemented on the data qubits by the dynamics. Note that the subscript label on the kets denotes the column where the qubits are, whereas the subscript label within the qubits specifies the state. Let us use [m] k to denote m modulo k. After t timesteps, the state is given by where, in particular, where G(P i ) are unitaries composed of the gates applied at each timestep as the input data column moves across the torus encountering new program qubits. The other vectors |D i (t) in equation (25) with i = 0 will have unitaries G(P i ) applied in some other order, but this is unimportant, as we are only interested in implementing the quantum algorithm on the input data in the first column. And to do this, we encode the necessary gates into the program qubits P i . For example, G(P 1 ) is given by Note that the product above only involves unitaries on the first two columns. Recall from earlier that these W n unitaries were specifically chosen to implement desired gates on the data qubits controlled on the program qubits. After r timesteps (any longer and the data qubits encounter program qubits twice) the output of the program can be read from column r. It was shown in [71] that with this setup, the choice of gates in equation (22) is sufficient to implement a universal gate set on the data qubits and hence simulate any quantum circuit efficiently.
A similar idea was used in [50], where again the circuit to be simulated is, in a sense, drawn onto a two-dimensional QCA.

Other ideas
A drawback of the method of the previous section, which maps the circuit onto a two-dimensional QCA, is simply that it is two dimensional. This may be difficult to do in a laboratory, so it may be more desirable for practical reasons to work with a one-dimensional QCA. That quantum circuits can be efficiently simulated by a one-dimensional QCA was shown in [72], which gave a construction for a universal one-dimensional QCA with 12 dimensional quantum systems at each cell. A stepping stone to get this result was a proof that QCAs with external classical control can be simulated by those without. In this context, a classically controlled QCA is a QCA where an external party can choose to evolve the system via one of some number of automorphisms at each timestep. (This is also sufficient for quantum computation [73].) By encoding which automorphism is to be applied at each timestep into the initial state, it is possible to get a truly autonomous QCA [72], albeit with a bigger state space.
An interesting related concept to the quantum computational universality we are interested in here is so-called intrinsic universality. For QCAs this amounts to finding a QCA that, after some regrouping of cells, can simulate any other QCA. This has been studied in detail in [74][75][76][77], where n-dimensional intrinsically universal QCAs were found [75,76].
One might speculate on the possibility of using fermionic QCAs as quantum computers instead of qudit QCAs. This would be a QCA analogue of using fermionic quantum circuits for quantum computation instead of qubit circuits [78]. Also, the opposite direction, simulating fermionic systems with qubit quantum circuits, is highly relevant for quantum simulations of physics [79]. For the quantum circuit model, it was shown in [78] that quantum computers using qubits can efficiently simulate quantum computers composed of fermions and vice versa. A similar result is true for QCAs: fermionic QCAs can simulate qudit QCAs efficiently and vice versa directly (without, e.g., simulating the circuit model first) [54]. In this case, the slowdown is constant in both directions.

Implementations
In contrast to the circuit model of quantum computing, which uses single and (typically) few qubit gates to build a global unitary circuit, quantum cellular automata involve global unitary operations, without necessarily requiring the ability to directly apply, e.g., single-qubit gates. This is often put forward as an advantage, as single-site addressability can be harder in practice [80].
One interesting possibility, first proposed in one of the earliest papers on QCAs [14], is to arrange three types of atomic species periodically in an ...ABCABC... pattern. Each species can be addressed independently with electromagnetic pulses tuned to have the resonant frequency of a species' ground to excited state transition. (Note that for each atom, the resonant frequency can be affected by the states of its neighbours, which is a useful feature in the proposal as it allows, e.g., conditional operations to be implemented.) With various different combinations of pulses, one can implement various different gates. The input and readout of data occurs only on the end qubits of the line. Later it was shown in [80] that two species in an ...ABAB... pattern suffices for universal quantum computation. (In fact, even a single species should be sufficient [73,81].) These kinds of models are what some authors mean by the name quantum cellular automata (e.g., in [82]), whereas, from our point of view, a better name would be classically controlled QCAs, as they typically involve different unitaries applied at each timestep.
This scheme was studied further in [83,84], and in [85] an implementation of this idea using endohedral fullerenes was analyzed theoretically. Endohedral fullerenes are C 60 fullerenes (these are molecules made of 60 carbon atoms that form a ball, sometimes called buckyballs) that have, e.g., an atom trapped inside the cage formed by the carbon atoms. And the idea of using these molecules as parts of a quantum computer met with a degree of experimental success in [86]. In that case, Nitrogen atoms were trapped in the fullerenes and the levels considered arose from a spin 3/2 electron coupled to 14 N nuclear spin I = 1.
While quantum computing via quantum cellular automata has its advantages (only global operations are necessary), the vast majority of work regarding quantum computing is focussed on other models, especially the circuit model. Perhaps because of this, there is, e.g., no well-developed theory of error correction in quantum cellular automata, in contrast to the quantum circuit model. (It may be straightforward to develop such a theory, and it would be interesting to see if it could be done without requiring few-qubit operations.) Furthermore, the current trend in building quantum computers is oriented towards quantum computers with a focus on few-qubit addressability in order to use the quantum circuit model.

Structure of QCAs
There are many results that allow one to understand the structure of QCA dynamics. In one dimension, QCAs are particularly well understood. For example, the index theory (discussed in section 5.2) classifies when two QCAs can be smoothly deformed into one another while preserving locality. In higher dimensions, a powerful result is given in the following section, where we see that QCAs, together with some local ancillas, allow us to view any QCA as a local finite-depth circuit.

Unitarity plus causality implies localizability
This result was first proved for qudits in [19], and it was later extended to QCAs with fermions and bosons in [58]. It is a little easier to understand the intuition if we prove this for finite systems as we always have a unitary implementing the QCA dynamics. Nevertheless, the proof is almost as straightforward for infinite systems and automorphisms. The trick is to consider the original QCA A with dynamics U A and an identical copy B, evolving via the inverse dynamics U −1 B . So for a qudit at site n in the A system, there is also a copy qudit from the B system (of the same dimension) at the same site n. Next, we need to introduce the global swap operation: where S n swaps the state of the qudits of system A and B at site n. Using this swap, we can decompose the dynamics of the A and B system: Crucially, S n is a local unitary at site n. Then, U B S n U † B must also be a local unitary localized on the inverse neighbourhood 7 of site n. This follows because U B is a locality preserving unitary and hence so is U −1 B . (For a simple proof of this, see, e.g., [19].) Therefore, we see that the dynamics of the joint system can be implemented as a finite-depth circuit. All the swaps S m can be implemented in parallel, and any U B S n U † B unitaries can be implemented in parallel as long as they act on non-overlapping regions. The minimum depth circuit is then given by max n |N B ( n)| + 1. Here N B ( n) denotes the neighbourhood of site n with respect to the unitary U B .
The result was later generalized to dynamical graphs in [87], where the QCA neighbourhood scheme could change over time. This was done with a view towards discrete models of quantum gravity, where spatial geometry may not be fixed in time.

Index theory in one dimension
In this section, we discuss the index for one dimensional QCAs, introduced in [88]. This was inspired by an analogous index for quantum walks [88,89], which was called the flow in [89]. Essentially, the index is a rational number that quantifies how much quantum information moves along the chain. Interestingly, the QCAs considered need not be translationally invariant, yet one can still assign an index to it. A key property of the index is that it is locally computable: the index can be computed by examining the dynamics locally, as we will see.

Qudit index theory
We first need to introduce a few concepts to define the index. In this section, we assume that the QCAs are nearest neighbour QCAs, which we can always achieve by regrouping sites. Regrouping works by grouping together sites on the original lattice into a single site on a new lattice. For example, we could regroup by defining B n = A 2n ⊗ A 2n+1 for all n for a one-dimensional system. Then B n are the cell algebras for the new regrouped system, each of which contain two cells of the original system.
Let us start by introducing support algebras [18,90]. The intuition underlying support algebras is that they describe, in some sense, the extent to which one algebra has overlap with another algebra. Note that, for most of our purposes, these algebras are finite dimensional.  S(A, B 1 ). This is defined to be the smallest C*-subalgebra in B 1 needed to build elements of A. More concretely, for any a ∈ A, we can decompose it as is generated by all b 1 i arising in this way.
Two algebras A and B commute, if each element a ∈ A and each element b ∈ B commute. If this is the case, we write [A, B] = 0. The following lemma (see, e.g., [88] for a simple proof) is a useful result, which shows that, if two algebras commute, their support algebras also commute.
Lemma 5.2.2. Suppose we have the C*-algebras B 1 , B 2 and B 3 . Let A 12 and A 23 be subalgebras of Then  Figure 9: Visualization of even and odd algebras. Importantly, e.g., R 2n rarely equals A 2n−1 ⊗ A 2n .
Another tool we need are the so-called even and odd algebras, which are defined to be These are best understood by looking at figure 9.
Recall that A n is the algebra at lattice site n. So after evolving A 2n ⊗ A 2n+1 by u, the image u(A 2n ⊗ A 2n+1 ) is a subalgebra of R 2n ⊗ R 2n+1 . These even and odd algebras roughly describe what information moves right and what information moves left along the chain. Next, we need the following important result about the even and odd algebras, which is worth proving.
which is the algebra of r m × r m complex matrices. Note that r m and hence the size of the algebra depends on m. Furthermore, Proof. First, note that all the R m algebras generate the full C*-algebra of the chain A. This follows because all A n generate the chain algebra, and u(A 2n ⊗ A 2n+1 ) ⊆ R 2n ⊗ R 2n+1 for all n. So because u is an automorphism, the algebra that all R m generate must be equal to A. The chain algebra is simple with trivial center, which means that only multiples of the identity commute with everything in A. So each R m must also have trivial center (note that [R m ,R n ]=0 for any n and m, so a non trivial center for one R n would imply a non trivial center for the whole chain). A consequence is that R m must be subsystem algebras [60], i.e., each R n is isomorphic to M rn the algebra of r n × r n complex matrices.
Finally, u(A 2n ⊗ A 2n+1 ) ⊆ R 2n ⊗ R 2n+1 cannot be strict because then there would be a non trivial element B ∈ R 2n ⊗ R 2n+1 commuting with all elements of u(A 2n ⊗ A 2n+1 ) and also all elements of the chain algebra, which is generated by u(A 2m ⊗ A 2m+1 ) for all m. And such an element does not exist.
We see from equation (34) where dim[·] denotes the dimension of the algebras as vector spaces. Also, we have R 2n+1 ⊗ R 2n+2 = u(A 2n+1 ⊗ A 2n+2 ), which follows because the R algebras generate the chain algebra, and R 2n+1 and R 2n+2 are the only ones that have support on sites 2n + 1 and 2n + 2. Then we get We may then define the index of a QCA to be which we can see from equations (35) and (36) is actually independent of n. And because A n is isomorphic to M dn and R m is isomorphic to M rn , we get the equivalent formula Below we list some basic properties of the index. These are proved in [88], where most properties follow straightforwardly from the definition of the index in equation (38). However, the last two highly interesting properties of the index listed below are harder to prove and tell us something about its robustness with respect to perturbations of the dynamics.

ind[u] = 1 if and only if u is locally implementable with
where V 2n are unitaries acting on sites 2n and 2n + 1, and W 2m+1 are unitaries acting on sites 2m + 1 and 2m + 2. So u is a finite-depth circuit. This need not be translationally invariant.
5. Two QCAs u 0 and u 1 with the same C*-algebras (i.e., the same cell structure) have the same index if and only if one can be continuously deformed into the other. This means that there exists a strongly continuous 8 path u t with t ∈ [0, 1] connecting u 0 to u 1 such that u t are QCAs with the same cell structure and neighbourhoods as u 0 and u 1 .
Property (2) and (4) together tell us that applying additional local unitaries cannot change the index, e.g., ind where v(·) = V † (·)V for some local V . Property (5) tells us that smooth deformations (in terms of the strong operator topology) also cannot change the index, so it is robust against these two types of perturbations. This robustness to perturbations is important in the application of the index to classifying chiral Floquet phases (section 6.2).

Another formula for the index
There is a different formula for the index which is quite useful [88]. To write it down, we need another method for quantifying the overlap of two algebras. The algebra of the whole QCA A has a normalized trace, i.e., a state τ , such that where A, B ∈ A. This state is essentially just the maximally mixed state but for an infinite chain. For any A, B ∈ A, τ (A † B) defines an inner product. Because A is a complex vector space, we can think of any two subalgebras B 1 , B 2 as vector subspaces of A. This allows us to quantify the overlap of these two subspaces. We pick orthonormal bases for B 1 and B 2 , and denote them by e α and f β respectively. Then we define the overlap of the algebras to be which is independent of the choice of orthonormal bases. We can also think of this as where P 1 and P 2 are the projectors onto the subspaces B 1 and B 2 . The trace here is the trace of operators on A viewed as an inner product space. 9 Note that η(B 1 , B 2 ) ≥ 1 if both subalgebras contain the identity. To get our second formula for the index, define where N and M can be any integer greater than zero. (Actually, the case N = M = ∞ makes sense and is also allowed.) Then we have This formula for the index is useful for applications to topological phases and is also needed to prove some properties of the index in [88]. It is worth mentioning that there is yet another formula for the QCA index, which is in terms of the Jones index [30]. The Jones index [91] essentially quantifies the multiplicity of one C*-subalgebra B in a larger algebra C. To be precise, B and C must be type II 1 factors (von Neumann algebras with trivial center). The theory of factors and subfactors is quite involved, but only a few properties are needed to write the QCA index in terms of Jones indices [30].

Fermionic index theory
We might guess that, via the Jordan-Wigner transformation [92,93], an index for fermionic QCAs should basically be the same as for qudit QCAs. In fact, this is not quite the case. The index theory does extend to fermions but it is somewhat richer [24]. Here we consider the case where each lattice site has some fermion modes and possibly also qudits. Most of the construction runs along the same lines as for qudits in section 5.2.1, with some complications arising because fermion operators on different sites do not necessarily commute.
The support algebra construction from section 5.2.1 also carries over, and so does lemma 5.2.2, with the only difference being commutators are replaced by graded commutators. (See appendix B for more on fermion QCAs, graded commutators and graded tensor products.) It is also straightforward to prove the analogue of lemma 5.2.3 [24], namely 9 In fact, this inner product space is the GNS representation of A generated by the state τ .
where ⊗ g is the graded tensor product, and From equation (45), we get where dim[·] denotes the dimension. Also, from equation (46), we get We then arrive at the formula which is independent of n, and looks just like what we had in the qudit case. So far, the extension to graded commutators has not caused us any problems. However, finding dim[R n ] is a little harder. In the qudit case, R n was a simple finite dimensional algebra and hence was isomorphic to the algebra of r n × r n complex matrices M rn (a consequence of the Artin-Wedderburn theorem). In this case, however, we can only guarantee that R n are semisimple (since any finitedimensional C*-algebra is semisimple). And one can show that each R n has trivial graded center [24]. Luckily, this is enough to ensure that a generalization of the Artin-Wedderburn theorem holds [24,94].
Lemma 5.2.4. A semisimple graded algebra with trivial graded center is isomorphic to either 1. C(p|q), the graded algebra of matrices acting on C p|q . This algebra has (complex vector space) dimension (p + q) 2 .
2. Cl 1 (p|q), the graded algebra of matrices acting on C p|q with matrix entries in C ⊕ C, which we can think of as a1 1 2 + bσ z , where a, b ∈ C. This algebra has (complex vector space) dimension 2(p + q) 2 .
So we know that dim[R 2n ] = m 2n (p 2n +q 2n ) 2 where p 2n , q 2n are positive integers, and m 2n ∈ {1, 2}. Then the index takes the form since dim[A n ] = d 2 n . (Note that, in the special case where A n just corresponds to, e.g, a single Majorana mode, dim[A n ] = 2, which is not equal to d 2 n with d n ∈ N.) So we see that, whereas the qudit QCA index took rational values, the fermion QCA index can also include a factor of root two. For purely fermionic systems (i.e., with no qudits but just some number of fermion modes on each site), ind[α] = 2 n/2 , where n ∈ Z. In contrast, for hybrid systems of qudits and fermions, any value given in equation (49) can be achieved.
A particularly illuminating example is the Majorana shift, introduced in [24]. Take a system that has a single fermion mode at each site with annihilation operators a i . Then consider the corresponding Majorana operators c 2i = a † i + a i and c 2i+1 = i(a † i − a i ). Define s M to be the automorphism 10 s M (c n ) = c n−1 .
Clearly, s M applied twice is just the fermionic shift, which would act as s(a n ) = a n−1 . We can verify from equation (49) that s M has index √ 2. So we can view s M as a square root of the usual fermionic shift, which has index 2. This is in stark contrast to a shift for qubits. There exists no QCA u, such that u 2 = s, where s is the shift by one site for qubits. This itself is a consequence of the index theory for qudits in section 5.2.1. The automorphism s has index 2 and so u would have to have index √ 2, which is impossible for qudits because their QCA index is always a positive rational.
Other consequences of the fermionic index theory are not quite the same as in the qudit case. For example, two QCAs with the same index are not necessarily equivalent up to local unitaries in this setting. We can see this with the following example. Consider a system with a fermion mode and a qubit at each site. Now consider two different QCA dynamics: a shift of the fermions one site to the right but acting like the identity on the qubits s f , and a shift of the qubits one site to the right acting like the identity on the fermions s q . These both have index 2. And we would hope that they would be related by a finite-depth circuit, but this is not true, as shown in [24].

Index theory in higher dimensions
Very recently, classifying QCAs using the index theory has been extended to higher dimensional systems [53]. The classification is complete for two dimensional qudit QCAs on finite lattices and depends on the topology of the control space (described in section 2.1). The completeness of the classification is not expected to extend to higher dimensional lattices (due to the probable existence of so-called non-trivial QCAs in higher dimensions 11 [95]), and it is not clear how it applies to fermionic QCAs. Nevertheless, let us now take a look at the ideas behind the classification in a little more detail.
First, we need to discuss the notion of equivalence used in [53]. Two QCAs with dynamics u and v are stably equivalent if, by possibly adding qudits to each site of the system, we have u = w • v, where w is a finite-depth local unitary circuit. This is a more general notion of equivalence than that used in section 5.2, as we are allowed to add ancillas to each site. Figure 10: Regrouping all sites along one lattice direction reduces the QCA to a QCA on a lattice with lower dimension. The dimension of the Hilbert space corresponding to each cell in the regrouped QCA will be higher as a consequence of the regrouping.
The classification works by using the one-dimensional index together with dimensional reduction, which is an extreme form of regrouping: each site along a lattice direction is regrouped into a single site, so that the resulting regrouped QCA acts on a lattice system of lower dimension, as illustrated in figure 10. Then the classification depends on one-dimensional indices (corresponding to dimensional reductions along different directions) as well as the topology of the underlying spatial manifold in the form of the first homology group and the torsion. 12 Let us look at some useful examples. Suppose our QCA lives on a discrete torus, with d-dimensional qudits at each site and coordinates (n, m), where n, m ∈ {0, ..., N − 1}. Now consider some possible dynamics for the QCA. One very simple example is the following: s K acts like the identity on all qudits, except those with coordinates (K, m) for all m and fixed K. On these s K shifts the qudit at site (K, m) to site (K, m + 1). Note the periodic boundary conditions with N ≡ 0. We can see that s K is not equivalent to the identity because we can consider the dimensional reduction in the x-direction to a one-dimensional QCA, which is a partial shift on a circle. This has index d and so is not equivalent to the identity. However, if we reduce this to a QCA along the other direction, we get an index one QCA. More interesting behaviour is given by the QCA that shifts qudits from site (n, m) to site (n + 1, m + 1) for all n and m. Whichever direction we reduce, we get a QCA with index not equal to 1. Figure 11: Subfigure (a) shows how two shifts in opposite directions (black arrows) are equivalent to a depth-two local circuit of swaps (red arrows). Subfigure (b) depicts dynamics involving many shifts in opposite directions. This is also equivalent to a depth-two local circuit, as long as there is a shift to the left for every shift to the right.
Much like the loops arising in the first homology group, shifts around loops play a key role in this classification. A useful argument shows us that any such "shift loop" on the torus can be contracted to any other (with the same index along the same direction) via a finite-depth local circuit. Let us sketch how this works. First, consider a QCA s 0 • s −1 1 which is just a shift of the qudits with coordinates (0, m) for each m and a shift in the opposite direction of all qudits with coordinates (1, m) for each m. Everywhere else it acts like the identity. As seen in figure 11 (a), this can be written as a product of swaps: first apply the swaps between sites (0, m) and site (1, m + 1) for each m. And then apply the swaps between sites (0, m) and site (1, m) for each m. So this QCA, which consists of two shifts in opposite directions that are beside each other, is equivalent to a finite-depth circuit. Now define a generalization of s 0 So if a = b = 0, we get s 0 • s −1 1 . Note that v a,b is also clearly equivalent to a finite-depth circuit by a similar trick, as depicted in figure 11. Now notice that But w is also a finite-depth circuit of swaps. Then we have s 0 = w • s N/2 , so s 0 and s N/2 are (perhaps surprisingly) equivalent up to finite-depth circuits despite being shift loops far away from each other. This idea also works in, e.g., the two-dimensional plane (possibly by adding local ancillas), though determining which loops are equivalent will depend on any holes in the plane.
Therefore, for the two-dimensional classification of QCAs, the first homology group of the covering manifold plays a big role, since it classifies loops in the manifold that cannot be contracted to a point. And intuitively, the same thing happens for shift loops around any "holes" in the manifold. The reason that torsion plays a role is also rather interesting. Roughly, a manifold has torsion if we can move a loop along the manifold so that it changes its direction (so this can only happen for non orientable manifolds). This means that we can use this topological property of the manifold to contract some seemingly non trivial pairs of shift loops to the identity. This can happen for a QCA with, e.g., the Klein bottle as its covering space.

Margolus partitioning
A generalized Margolus partitioning method for translationally invariant QCAs was first introduced in [18]. It gives us a different method of constructing a QCA from local unitaries. A crucial point about this decomposition is that the local unitaries are not generally unitaries on subsystems but rather local unitary maps from one subsystem to another. This is a significant departure from, e.g., the local finite-depth circuit QCAs we have already seen (sections 1.1 and 3.2).
Let us introduce the construction for one-dimensional QCAs with d-dimensional qudits at each site. (The generalization to higher dimensions is straightforward.) First, we introduce a generalized Margolus partitioning (given in [18] and generalized from [96]). We regroup so that the QCA is nearest-neighbour, and then we define the supercell to contain two sites: In higher dimensions, we would have a larger cube as our supercell. Then we define A = A 0 ⊗ A 1 , and more generally we define A +2m = A 2m ⊗ A 2m+1 , where m ∈ Z. We define the algebras B 2m ⊆ A +2m−1 and B 2m+1 ⊆ A +2m+1 , with B n ∼ = M b(n) , the b(n) × b(n) complex matrices. Consider the algebras B 2m+1 and s −2 (B 2m ), where s is the shift. Notice that these are both subalgebras of A +2m+1 . The central assumption necessary for the construction of QCAs via Margolus partitioning is that these algebras commute and they also generate A +2m+1 . We may then define an automorphism using this partitioning via two steps: first, for each m ∈ Z, we have a map where w m (·) = W † m · W m and W m is a unitary. This is followed by with v m (·) = V † m · V m and V m unitary. Then the QCA automorphism is given by See figure 12 for an illustration of how this works. It helps to consider how this looks for a shift QCA.
In that case, B 2m = A +2m−1 and B 2m+1 is just C1 1. So the shift can be written in terms of local unitary maps in this way. But as we saw in section 5.2, there are QCAs (such as a shift) that cannot be written as a local unitary circuit. The point is that those circuits involve unitaries on systems, as opposed to the more general unitary maps we have considered here. So QCAs written using this partitioning scheme may not be implementable by a constant-depth quantum circuit. In fact, any one-dimensional QCA with d-dimensional qudits at each site can be written in this Margolus-partitioned form (which is proven in [18] for translationally invariant QCAs in one dimension). The proof follows by defining B n := R n , where R n denotes the support algebras from section 5.2. The proof in [18] is actually stated as applying to higher dimensions too, but this is not true, as a counterexample was found in two dimensions in [60]. Nevertheless, one can still construct QCAs in higher dimensions via a Margolus partitioning scheme, and this found application in, e.g., [71,97].

Matrix product unitaries
Our final structure result for QCAs involves tensor networks. It turns out that translationally invariant QCAs in one dimension are actually equivalent to a type of tensor network known as matrix product unitaries [97,98]. (For a good review of tensor network methods, see [99].) This equivalence is not true if we relax the requirement of translational invariance: QCAs are still MPUs, but an MPU need not be a QCA because it may no longer be a locality-preserving operation. The motivation for this decomposition of QCAs in terms of tensor networks is that it is useful for characterizing symmetries of QCAs [97,100], and also topological phases of Floquet models [23].
First, let us introduce translationally invariant matrix product unitaries. (Note that we work in the Schrödinger picture in this section.) We have a one-dimensional system with periodic boundary conditions and d dimensional qudits at each site. A translationally invariant matrix product unitary is constructed out of tensors w ij αβ . Here i, j ∈ {0, ..., d − 1} are the physical indices and α, β ∈ {0, D − 1} are known as bond indices, where D is a positive integer, known as the bond dimension. It helps to think of indices i and j as labelling different matrices and α and β as indices specifying the matrix elements. The associated matrix product unitary is then where the w ij matrices are being multiplied inside the trace (i.e., the bond indices are contracted), and the trace is also over the bond indices. The ket |i 1 , ..., i N is a basis for the N -qudit Hilbert space. As usual for tensor networks, this is best understood in terms of a picture, as in figure 13 (a). We can consider a simple example, a shift. In this case, the simple tensor does the job, as displayed in figure 13 (b). Notice that the bond dimension is equal to the qudit dimension in this case. Next, let us convince ourselves that a one-dimensional QCA of d-dimensional qudits is always a matrix product unitary. To do this, we will regroup so that the QCA is nearest neighbour. As we saw in section 5.4, we can write the QCA in terms of local unitary maps. The trick now is to rewrite each V m in the local map decomposition of the QCA from equation (57) in an operator basis. We know that v m (·) = V † m · V m maps B 2m+1 ⊗ B 2m+2 to A 2m+1 ⊗ A 2m+2 (in the Heisenberg picture). Let us drop the position index for a moment, so we have that v(·) = V † · V takes B ⊗ B to A ⊗ A , where, e.g., B = B 2m+1 . In terms of Hilbert spaces, V is a unitary from H A ⊗ H A to H B ⊗ H B . Note that, e.g., dim(H A ) need not equal dim(H B ), but we must have that dim( . Let X r denote a basis of linear maps from H A to H B and let Y r denote a basis of linear maps from H A to H B . Then we can write V in the form where c rs ∈ C, and d X Y is the dimension of the space of linear maps from H X to H Y . This can be condensed by using singular value decomposition to get wherec γ ∈ C and D ≤ max{d AB , d A B }. Absorbing the numberc γ into the operatorX γ and plugging back in the position dependence, we get Now we define the tensors So now we have a decomposition of the QCA in terms of local tensors (see figure 14). Thus, any QCA in one dimension can be viewed as matrix product unitary. It can be shown (in the translationally Figure 14: In subfigure (a) we see the decomposition of the unitary map V n into a sum over γ of tensor products of mapsX γ 2m+1 ⊗Ỹ γ 2m+2 . The thicker and thinner input and output lines highlight that the dimensions of the local vector spaces may be different. Subfigure (b) shows how the tensor building the matrix product unitary representation of the QCA unitary is put together. Note that the input and output indices act on two neighbouring qudits of the QCA. invariant case) that the converse of this result is also true, namely that any matrix product unitary is equivalent to a QCA [97]. This matrix product unitary approach allows a different derivation of the QCA index [97].
These MPUs can be further classified in the presence of on-site unitary symmetries [100]. This works similarly to the classification of matrix product states in the presence of symmetries [99]. The main result of [100] is that one-dimensional matrix product unitaries are completely classified by (i) the QCA index and (ii) the cohomology class of the representation of the symmetry group acting on the bond indices. The classification considers two matrix product unitaries U 0 and U 1 to be equivalent if, possibly by adding ancillas transforming under arbitrary representations of the symmetry group, there is a continuous path of matrix product unitaries U t joining U 0 and U 1 . If we restrict our attention to equivalence under only appending local ancillas that all transform under the same representation, then the classification can be further refined, though it remains incomplete. Non-unitary symmetries, relevant for, e.g., the tenfold way in condensed matter physics, are discussed in [97], where (i) complex conjugation, (ii) transposition and (iii) time-reversal symmetric MPUs are classified to some extent. In this case, the classification of matrix product unitaries that are symmetric under complex conjugation is complete.

QCAs in physics
Aside from being a model for quantum computation, QCAs arise in physics, for example, as effective models for Floquet dynamics or as proposals for quantum simulators. One of the reasons this is natural is because QCAs have an inherent maximum speed of propagation of information. Depending on the setting, this speed can be identified either with the speed of light, if we are approximating a relativistic system with a QCA; or we can identify it with the speed of sound or Lieb-Robinson velocity if we are approximating non-relativistic systems. In the following sections, we will look at both of these applications, but first let us look in more detail at the differences between QCA dynamics and continuous-time Hamiltonian evolution.

QCAs vs Hamiltonian dynamics
We can simulate the dynamics of continuous-time systems on lattices with local Hamiltonians by using the Suzuki-Trotter decomposition [16,101,102]. By ordering the unitary gates in the right way [54], we get a QCA. A different approach uses Lieb-Robinson bounds [22] to ensure that we can approximate continuous-time dynamics with high accuracy using a QCA [103,104]. For any such simulation methods to work, it is essential that the continuous-time model has some approximate locality-preserving property, e.g., it obeys Lieb-Robinson bounds. On the other hand, continuous-time evolution cannot be strictly locality preserving. Let us convince ourselves of this fact.
Consider qudits on a lattice, evolving via the time-independent Hamiltonian H. And consider an operator localized at site 0 at t = 0, so A ∈ A 0 . Now suppose the dynamics is locality preserving in a strict sense. This means that there would be some time T , such that, for all t < T , the evolved operator e iHt Ae −iHt is strictly contained within some finite region R containing the point 0. So, for any B localized outside of R and any t < T , we must have [B, e iHt Ae −iHt ] = 0. Taylor expanding for small t, we get ] = 0 for all t, which tells us that the operator e iHt Ae −iHt never actually has support outside of the region R for any time t. And this is true for any A ∈ A 0 . Hence, if information is ever going to spread from 0 to outside R, it does so immediately, though with a very small amplitude in general. This simple argument shows us why we need to consider discrete time for lattice systems if we want our dynamics to be strictly locality preserving.
Another interesting question regarding the connection between Hamiltonians and QCAs is whether there is a natural way to associate a Hamiltonian to a QCA. For finite lattices, we always have a unitary U implementing the dynamics, so we can define H by U = e −iH . A drawback of this prescription is that it is not unique because we can add multiples of 2π to the eigenvalues of H and still get the same U . Furthermore, this Hamiltonian will generally not be strictly local 13 (i.e., a sum of local operators on the lattice), as can be seen by writing H = i ln(U ), defined as a power series: which holds as long as U − 1 1 < 1 [105]. This contains interactions between sites arbitrarily far away from each other, though the strength of the interaction between sites decays with distance. Interestingly, one can construct QCAs such that all Hamiltonians H satisfying U = e −iH are fully non-local, meaning that the interaction terms in H between different regions do not decay with distance [106]. For this to be possible, the unitary must violate U − 1 1 < 1, so that the right hand side of equation (66) does not converge. A related question for QCAs is whether there is a meaningful notion of a ground state or energy ordering. Because the eigenvalues of a unitary are complex phases, there is no natural way to order the eigenvalues. This means that there is no clear way to decide which state has the lowest energy. For simulating dynamics via QCAs, this may not be much of a problem, but this is important to take into consideration if we wish to view QCAs as something more fundamental. This is because understanding low energy and ground state properties of physical systems plays a huge role in, e.g., condensed matter and high energy physics. But for Hamiltonians there is a natural ground state and a meaningful notion of an energy gap. At the moment, there appears to be nothing similar for QCAs.
There is one final setting where QCAs arise naturally: as approximations to or toy models for periodically driven quantum systems, also known as Floquet quantum systems [107]. Suppose we have a lattice system and a time-dependent Hamiltonian H(t) that is periodic with period T , i.e., for all t, The Schrödinger equation is This has solutions [107] |Ψ where |Φ α (t + T ) = |Φ α (t) .
Here, α are found by solving (H(t) − i∂/∂t)|Φ α (t) = α |Φ α (t) . These are called quasi-energies, and they are real and unique up to adding integer multiples of 2π/T . If we restrict our attention to times t = nT , where n ∈ Z, then we have a discrete-time system evolving via U n , where U is a unitary operator, given by where T is the time-ordering operator. Typically, U will not be locality preserving, but even in the time-dependent case, Lieb-Robinson bounds are enough to guarantee that we can approximate the dynamics well with a QCA [103,104]. This allows us to use QCAs as toy models for Floquet systems and to use QCA techniques to understand some of their properties, as we will see in the following section.

Topological phases in Floquet systems
In general, topological phases of matter are phases that do not fit well into the classification of phases in terms of symmetry breaking [108]. Instead, they are classified by topological properties of the system. A key example is the integer quantum Hall effect, where the topological classification arises from Chern numbers in the TKNN formula for the Hall conductivity [109]. The quantized Hall conductivity can be observed when such a system (which consists of non-interacting particles) is at temperatures low compared to the gap, and so the system is close to its ground state. Then one observes the existence of chiral edge modes: in the two-dimensional bulk of the material the system is actually an insulator, but along the boundary these chiral edge modes allow the material to conduct. A requirement for this phenomenon to occur is that there is some disorder in the system, which leads to localization in the material. The integer quantum Hall effect involves the low temperature physics of static systems. But we may also ask whether similar phenomena can occur in dynamical systems. To answer this question, dynamical topological phases have been introduced and classified in Floquet systems [110][111][112][113] for non-interacting particles. These are called anomalous Floquet-Anderson insulators, and one again sees the presence of propagating edge modes on a two-dimensional material. It became clear later in [23,24] that this phenomenon can persist even in the presence of interactions. Here we will look at the models given in [23], which display this behaviour, admitting information propagation only along the boundary.
The paradigmatic example is quite intuitive and works as follows. Take a two-dimensional lattice Γ, where each site has d dimensional qudits. Suppose the system evolves by a simple QCA, which is a depth-four quantum circuit, where each unitary in the circuit is simply a swap, as depicted in figure 15 (a). Let e 1 and e 2 be lattice basis vectors and denote the swap between sites n and n + e i as S n, n+ ei . Define the sublattice Γ even = {(n, m) ∈ Γ|n + m is even}.
We consider evolution via where This is easiest to understand by looking at figure 15 (a). If Γ is the infinite plane or a torus, then it Figure 15: Subfigure (a) shows the Floquet dynamics on the infinite plane. The green swaps are applied first, orange are second, purple third and blue swaps are applied last. By following the path of a qudit, we see that the dynamics after all four swaps is the identity. In subfigure (b) however, a boundary has been introduced, and we can see that some of the qudits at the boundary have nontrivial dynamics.
is clear that U is actually just the identity: a qudit gets moved around a plaquette back to where it started. On the other hand, if we introduce a boundary, then qudits in the bulk still stay put after one timestep, but qudits at the edge propagate. See figure 15 (b). Notice that in this case we have a one-dimensional QCA at the boundary: a shift of d-dimensional qudits each timestep. By layering two of these two-dimensional systems on top of each other, where one has d 1 -dimensional qudits at each site undergoing the evolution given above, and the other layer has d 2 -dimensional qudits at each site undergoing the inverse evolution, we get a trivial bulk theory but a one-dimensional QCA on the boundary with index d 1 /d 2 . The central idea of [23] is that this index classifies the chiral propagation on the boundary and hence the topological phase. The examples here with qudits are then representatives for each different phase, as we can get a QCA with any boundary index with the right choice of d 1 and d 2 .
Of course, any phase classification is physically meaningless without some sort of stability against perturbations. We already know that the index is stable with respect to local perturbations (see section 5.2), so this classification should be stable with respect to local defects at the boundary, but what about bulk perturbations? This is where assuming localization comes in. Just as was the case for the integer quantum Hall effect, we need to demand that the systems under consideration have some form of localization to ensure that we get well-defined phases. In this case, because we are dealing with interacting systems, we make the requirement that the system is many-body localized. Let us take a quick detour to introduce many-body localization in Floquet systems.
We take as our definition for a many-body localized Floquet unitary U that (for an infinite lattice system) there exists a localization length ξ, such that where [V n , V m ] = 0 and V n is supported on a region N ( n) centred on n of radius ξ. 14 (Actually, we need only require that V n is approximately supported on N ( n), allowing some exponential decay outside.) As a very simple example, consider qubits with where J n are real numbers. This is just a product of on-site unitaries and so is clearly many-body localized in this sense. We will use this many-body localization property to define the phases in a way that is stable against bulk perturbations. To do this, we look at two unitary operators that act on the infinite system Γ inf and the system with boundary Γ fin . First, for dynamics on the unbounded system Γ inf , we have a decomposition of the dynamics into local commuting unitaries because we are assuming many-body localization. Then, for the system with boundary, we may define a unitary operator from a product of these local unitaries restricted to Γ fin to be where the product only includes terms that are localized on the system Γ. Importantly, this is not the actual dynamics of the system. Instead, that is given by considering which physical Hamiltonian terms act on the system where H fin (t) is the Hamiltonian consisting of terms contained in Γ fin . The exact details of H fin (t) do not matter, but U dyn itself does. For example, in the simple four-step swap dynamics we considered in equation (72), U dyn just involves swaps on the lattice between subsets of vertices. In that case, where there is a boundary, some swaps cannot occur, as in figure 15 (b). Now we define Y = (U lc ) † U dyn . Because of the many-body localization property, this can only be a non trivial unitary close to the boundary, as the local unitaries in (U lc ) † cancel the bulk dynamics in U dyn . We classify the phases according to the QCA index of Y as a one-dimensional boundary QCA. Let us see how this works for the swap example.
Suppose we augment the swap evolution defined in equation (73) with local commuting unitaries W = n W n , so that now the dynamics are given by On an infinite lattice or discrete torus, we know that As we saw earlier, on the system with boundary is just a shift along the boundary, which we will denote by S B , so that U dyn = W S B . But then Y = (U lc ) † U dyn is simply the shift of qudits along the boundary S B . This has index d.
There is an important point regarding this phase classification that we have glossed over. In reality, a QCA will only be an approximation to the actual dynamics. However, by choosing the neighbourhood size of the QCA to be at least as big as the Lieb-Robinson cone after one period of the dynamics T , this will be a very good approximation [103]. One might speculate that the classification via the index theory may not work simply because the index may not stop changing as we consider better and better approximations to the true dynamics (which will have larger and larger neighbourhoods), and it is conceivable that the index could converge to an irrational number. It may be that this concern is unwarranted, especially if one considers, e.g., the case of qubits, where the index must always be an integer power of two. Then the allowed index values are not dense in R, so the index cannot converge to anything other than a power of two (or zero). Nevertheless, it would be a worthwhile pursuit to extend the index theory to almost locality-preserving unitaries to back up this intuition.
A proposal for actually measuring the index characterizing information flow along the boundary of a two-dimensional Floquet system has been made [114]. Interestingly, in a very different context QCAs offer an approach for classifying symmetries in topological phases in higher dimensions [115]. In this case, the symmetries of the system, rather than the dynamics, are described by QCAs.

QCAs and particles
In this and the following sections we will construct QCAs that have a clear interpretation in terms of particles. To do this, it is natural to first look at the single-particle analogues of QCAs, which are called discrete-time quantum walks. These consist of a single quantum particle evolving on a lattice unitarily, with the restriction that the particle can hop at most by a bounded distance each timestep. 15 This is the single-particle version of locality preservation. These discrete-time quantum walks have many nice properties: with the right choice of unitary, we recover relativistic dynamics in the continuum limit, e.g., [34]; the symmetry-protected topological phases of these models can be classified [116][117][118][119]; and they also have more direct applications in quantum computing [120].
With this in mind, it is interesting to consider the possibility of constructing QCAs that are simply many-particle versions of these quantum walks. As a consequence, in the non-interacting setting much of the analysis that applies for quantum walks (e.g., the classification of topological phases) should also apply to these QCAs. On the other hand, we can also add interactions and arrive at entirely new physics. Before considering how to upgrade quantum walks to QCAs, let us look at a particularly important example of a quantum walk.
Consider a quantum particle on a discrete line with coordinates n ∈ Z and an extra two-dimensional degree of freedom with basis states |l and |r . Then an orthonormal basis of the whole Hilbert space is simply given by |n |l and |n |r where n ∈ Z. We define the unitary σ x = |l r| + |r l|, and then we can consider the following unitary implementing the evolution: where m ∈ R, a is the lattice spacing, and S is a shift for a single particle, i.e., S|n = |n + 1 for all n. In the continuum limit, m will be the mass. The term on the right in brackets is a conditional shift: if the particle is in the r state, it moves one step to the right, and if it is in the l state, it moves one step to the left. If we switch to momentum space, we have where p ∈ (−π/a, π/a] is the lattice momentum and p|q = 2πδ(p − q). In this basis, the shift is just a phase S|p = e −ipa |p . Then, defining σ z = |r r| − |l l|, we can rewrite the conditional shift as where P = dp 2π p|p p| is the lattice momentum operator. This allows us to write the evolution operator as U = e −imσxa e −iP σza .
Acting on smooth states (those with bounded momenta |p| ≤ Λ π/a), we can look at many timesteps N = t/a, to get As long as we choose our cutoff Λ to grow sufficiently slowly as a → 0, we get a sensible continuum limit, with the last line above corresponding to evolution via the one-dimensional Dirac equation with Hamiltonian H = P σ z + mσ x . A lot of interesting work has been done using this simple yet powerful quantum walk [35,121,122]. This includes studying, e.g., how mass mixes chiralities and Zitterbewegung [123].
We can also construct quantum walks in higher dimensional spaces that give rise to relativistic particles in the continuum limit [34], which is in some sense generic [124]. For example, to discretize the Weyl equation, we take a cubic lattice with coordinates n ∈ Z 3 and let the particle have a two dimensional extra degree of freedom with orthonormal basis states | ↑ z and | ↓ z , which correspond to spin in the continuum limit. 16 The evolution operator is where is a conditional shift along the b axis depending on the spin in the b direction. 17 We can take the continuum limit of this quantum walk just as we did for the one-dimensional case, which is done rigorously (an explicit proof of convergence for regular initial conditions is given) for this quantum walk and more in [125]. In the continuum limit, the dynamics is described by the Weyl equation with Hamiltonian H = P . σ [34]. It is straightforward to extend this to, e.g., the massive Dirac equation in three dimensional space.
There are at least two natural ways to upgrade single-particle quantum walk dynamics to QCAs. One way goes via quantum lattice gases, and the other is by second quantization. It is worth highlighting that we can discretize many physical models with quantum walks, e.g., Dirac or Weyl particles in curved spacetime [126][127][128] or in external gauge fields [36,129] or both [130], and so these models can also be upgraded to QCAs. As an aside, it is also possible to construct the Feynman propagator in some cases for quantum walks [131].

Lattice gases
The study of quantum lattice gases dates back to the early days of QCAs [39,[132][133][134][135], and a nice discussion can be found in [136]. The dynamics, which is generally taken to be translationally invariant, consists of two steps: a step where particles on the lattice propagate without interaction, and an interaction (or scattering) step between particles on the same site. So the idea is that each lattice site has up to d particles. For each particle, there is a k-dimensional qudit, with algebras B j n ∼ = M k , which describes the states of the jth particles at that site. As B j n corresponds to a kdimensional quantum system, each particle has k − 1 possible internal states, with the remaining state corresponding to the empty state |q n,j , which represents the absence of the particle. The algebra for each site is then A n = ⊗ j B j n . To define the dynamics, we choose d lattice vectors e i , and the propagation step simply shifts the jth particle by e j , meaning σ : B j n → B j n+ ej .
The interaction step is a product of on-site unitaries, which are the same at each site: The dynamics comprises the propagation step followed by the scattering step, u = vσ. Quantum lattice gas automata are usually defined with a quiescent state. For finite systems this has the form where Γ denotes the spatial lattice (this state also makes sense for infinite systems, where it is defined by its expectation values). This carries the interpretation of the completely empty state, i.e., the state with no particles at all present. Let us consider an example in one dimension that corresponds to a lattice gas version of the singleparticle evolution in equation (83). Suppose that each lattice site has two qubits labelled by l and r. So the on-site algebra is A n = B l n ⊗ B r n . Let the quiescent state be the zero state of all qubits where Γ = {0, ..., N − 1}. And if any qubit is in the |1 state, then there is a particle present. For example if the l qubit at site n is in the one state, there is an l type particle at site n. We choose the propagation step to simply shift the l qubits left and the r qubits right, so σ : The interaction term at site n is then implemented by the unitary (dropping the n subscripts) where |ab denotes a state with a ∈ {0, 1} l particles present and b ∈ {0, 1} r particles present. Here we see that V preserves the empty state, as |00 is taken to |00 , while the left and right handed particles are mixed to some degree by the mass term. We have some freedom left (after demanding that the single-particle sector evolves as the original quantum walk), which involves choosing the phase that is applied when both particle types are present e iφ . We can use this to model an on-site interaction between the particles. A general recipe for upgrading quantum walks to QCAs in a way similar to quantum lattice gases also appeared in [18,30,137]. It is also interesting to look at this from a different perspective: we may ask when are QCAs equivalent to quantum lattice gases [63], in other words, when do they allow a particle interpretation in the way we have described here? It has been shown that one can construct QCAs that cannot be written as quantum lattice gases despite propagating information [136]. Even taking products of quantum lattice gas automorphisms does not generate all QCAs [136]. Finally, it is worth mentioning that a general proposal for discretizing fermions interacting with gauge fields via quantum lattice gases was given in [138,139].

Fermions
Next we consider the second option, which is second quantization. 18 We will only look at fermionic second quantization here, but it is also possible for bosons. In fact, the lattice gases of the previous section could be considered as hardcore bosons, which are bosons with an on-site repulsive interaction that is so strong that only one boson of that type may be present at each site. Let us go through how fermionic second quantization works. To every state |α of an orthonormal basis of our original single-particle system, we associate a fermion creation operator ψ † α , such that Now, in the many-particle Hilbert space there is an empty state |0 , which is annihilated by all the annihilation operators, i.e., ψ α |0 = 0 for all α. Next we may define a linear map Q from singleparticle states to creation operators, which we can also define for adjoints. Given a single-particle state |v = α c α |α , Q is defined by This also extends to operators on the single-particle space in a natural way. Consider the single-particle Hamiltonian h = E E|E E|, then we have where ψ E = Q( E|). Now, we can upgrade our quantum walk operator in equation (83) to a QCA evolution operator. First, denote a complete set of annihilation operators corresponding to the singleparticle states |n |l and |n |r as ψ nl and ψ nr . For compactness, we can write this as a two-component operator ψ n = (ψ nr , ψ nl ) T . Analogously to the single-particle case, we can switch to momentum space, and we have the two-component momentum space annihilation operator Then the Dirac QCA in one dimension has evolution operator given by It is straightforward to check that this gives the correct dynamics, e.g., W T ψ † n |0 evolves exactly as a one-particle state should over T timesteps. The second term above is a conditional fermionic shift: it shifts ψ nl to the left and ψ nr to the right. This is clearly locality preserving, as is the first term above, which simply gives a phase to each annihilation operator: by switching to position space we have that which is a product of on-site unitaries. Therefore, W itself is also locality preserving. Of course, the main reason for using second quantization is to look at interacting systems, which works via adding another unitary step to the dynamics, e.g., which gives a phase if there are two particles at the same site, analogously to an energy penalty, e.g., from Coulomb repulsion of electrons. Then the overall dynamics is given by U = V W , and this QCA is referred to as a Thirring quantum cellular automaton [140]. This is essentially a second-quantized version of the interacting quantum walks considered in [141,142].

Quantum field theory
A good reason to discretize quantum field theories with QCAs is that they are already algorithms for simulating the dynamics of QFTs on a quantum computer, which retain nice properties of QFT like strict causality, i.e., locality preservation. However, any QCA discretization breaks Lorentz symmetry, something that also occurs for lattice quantum field theory. Nevertheless, some attempts have been made to introduce a discrete version of Lorentz symmetry for QCAs [143]. One approach is to consider a change of observer as a change of representation of the dynamics (without explicit reference to spacetime), which can be done in such a way as to reproduce the familiar Lorentz group in the low momentum regime for the Dirac and Weyl QCAs [144]. The emergence of a modification of special relativity, doubly special relativity (where there is a frame-invariant length as well as speed) was also studied for QCAs in one dimension [145]. It is interesting that strongly interacting QFTs are often defined to be the continuum limit of lattice quantum field theories (i.e., lattice models with local Hamiltonians) [146]. So QCAs may offer an alternative definition of some QFTs too. An early work on the connection between QCAs and field theory is given for example in [147], though this differs at least superficially from our notion of QCAs in the following way: to update the system to timestep τ + 1, one needs to know the state at times τ and τ − 1.
Recently, several quantum algorithms have been proposed that efficiently simulate some quantum field theories (φ 4 theory [148] and the Gross-Niveau model [149]). These algorithms did not use QCAs to simulate the dynamics but rather Suzuki-Trotter decompositions of the evolution operator (e −iHt , where H is the Hamiltonian of a suitable lattice QFT). However, an important point to highlight here is that the difficult part of these proposals was not simulating the dynamics but rather the initial state preparation [148,149]. Nevertheless, it is interesting to consider QCAs as natural discrete models, which provide alternative options for quantum simulations. One advantage of a QCA approach could be their simplicity: for example, to simulate the dynamics of Weyl fermions via a QCA, we need only implement swaps on the lattice [58,150]. Interactions are then provided, as in equation (98), by on-site unitaries.
A nice example of a QCA was introduced in [151] that discretizes a fermionic QFT called the massive Thirring model (though the work actually pre-dates QCAs and so does not use the name QCA). After taking a (not so rigorous) continuum limit of the QCA, the dynamics is given by the Hamiltonian where g is a constant. The rightmost term is the interaction term, so setting g = 0 would simply give us free Dirac fermions in one dimension. A QCA that discretizes this was already given in the previous section: the QCA is a lattice system with fermionic creation and annihilation operators with extra index l and r, and the evolution operator is given by Recall that ψ pl and ψ pr are the Fourier transforms of ψ nl and ψ nr respectively, and ψ p = (ψ pr , ψ pl ) T . Here, we can naively see that the continuum limit dynamics should correspond to the Hamiltonian in equation (99). How one shows this is given in detail in [151], though the evolution operator for the QCA is slightly different in that case, but the basic idea is the same. See also [140].
A crucial point to bear in mind is that the discrete analogue of the physical ground state is not the state |0 annihilated by all the annihilation operators ψ nα . This is because the vacuum in QFT is a highly entangled state [62], and the QCA must reproduce this entanglement in the continuum limit. Even in non-interacting QFTs, there is vacuum entanglement, so we cannot simulate the QFT ground state via the naive QCA vacuum state |0 , which has no entanglement. For the onedimensional massless Dirac QCA, convergence of the QCA to the massless Dirac field was shown in [54], a consequence of which was that there is a choice of QCA vacuum that converges to the quantum field vacuum.
More recently, there has been much work on discretizing non-interacting fermionic fields by QCAs [58,150,[152][153][154][155][156], which consider Dirac and Weyl QCAs in higher dimensional spaces. Furthermore, the one-dimensional Dirac QCA model was actually recently rederived in a QFT context [157]. Of course, the more interesting cases are QCAs that discretize interacting quantum field theories, as in the example given in equation (100). Another example of an interacting fermion QCA that discretizes an interacting quantum field theory, in this case quantum electrodynamics in one spatial dimension, was given in [158]. Another interesting discrete model of a quantum field theory is the so-called QCA theory of light [159]. This is not dissimilar to a discretized version of the neutrino theory of light [160] and constructs a QCA approximating quantum electromagnetism (without matter) from two Weyl QCAs in three dimensional space. At a very superficial level, the main idea is to use that the vector of Pauli matrices σ transforms like where J i form a representation of the generators of the lie algebra of SO(3) given by [J i ] jk = −i j,k ε ijk , where i, j, k all take values in {1, 2, 3}. Then, roughly speaking, the dynamics causes a bilinear fermion field M i ( p) = ψ p σ i Ψ p to evolve as where ψ p and Ψ p are two different two-component fermion fields in momentum space. This is equivalent to We then define the electric and magnetic field operators in terms of M i If we also introduce the constraint that p. M ( p, t) = 0, then we recover Maxwell's equations for E i and B i . Of course, there are many details that have been swept under the rug here, which are dealt with in [159]. For example, one also has to ensure that the correct commutation relations for E i and B i are recovered. Another point about the model is that it is not clear how to extend it to an interacting model via coupling to matter because the electric E( x) and magnetic fields B( x) are the fundamental quantities in the QCA, as opposed to the electromagnetic four-vector potential A µ ( x). Due to phenomena like the Aharanov-Bohm effect, one would expect that any direct coupling of the E( x) and B( x) fields to matter would have to be non-local.

Outlook and open problems
We have looked at many interesting aspects of quantum cellular automata, including their use in quantum computation, their structure theorems, and their role in physics, e.g., as models of Floquet topological phases. At the moment, however, there are also many fascinating open problems related to QCAs. Here we list some as well as some possible ideas to tackle them. 3. What can be said about irreversible QCAs, which have only received little attention in, e.g., [17,49]. At the moment, there are only constructive definitions. For example, it makes sense to give examples of irreversible QCAs by taking a finite-depth circuit of local completely positive trace-preserving maps. But is there any reasonable axiomatization that seems physically motivated and which also allows useful structure theorems? Even for probabilistic classical cellular automata, this is not at all straightforward [161].
4. When does it make sense to talk about ground states for QCAs? A related question is whether there is any systematic way (other than exact diagonalization for finite systems) to find invariant states for QCAs, perhaps by getting some local constraints on the state. One might then in some cases try to define a ground state for a QCA by finding an invariant pure state that has low entanglement. For some ideas in this direction, see [49].
5. Can one generalize the correspondence between matrix product unitaries and QCAs to higher dimensional systems? In other words, when are QCAs equivalent to tensor network unitaries in higher dimensions? (This may be related to item 1 above.) The matrix product unitary equivalence relied on the Margolus partitioning result for one-dimensional QCAs from section 5.4.
As it is known that some QCAs in higher dimensions cannot be decomposed via Margolus partitioning, it would be interesting to see if the counterexample to this result in higher dimensions (see [60]) can or cannot be written as a tensor network operator. 6. What more can be said about QCAs with symmetries? For example, when is there a symmetryprotected topological classification of QCAs in one dimension (with symmetries as in the tenfold way, which are a combination of time-reversal, chiral and particle-hole symmetry [162])? Progress in this direction has already been made for one-dimensional QCAs via the matrix product unitary approach as discussed in section 5.5, as these approaches allow some classification of some unitary and antiunitary symmetries for one-dimensional QCAs.
7. How can we take continuum limits of interesting QCAs? So far all models with continuum limits are integrable (solvable in some sense). It is not clear how to go beyond this. In lattice QFT, continuum limits are typically signalled by a second order phase transition. Is there any analogue of this for QCAs? Another idea would be to use the framework for general continuum limits from [163].
rather than any particular representation in terms of operators on a Hilbert space. This is related to the existence of superselection sectors, see [165]. Let us start with the definition of a C*-algebra.
Definition A.0.1. A C*-algebra A is a complex algebra with a norm · in which it is complete as a vector space (making it a Banach space) and with an anti-linear map, A → A * , which is an involution, with the following properties: We will also assume that our C*-algebras have an identity. It is useful to keep in mind that any closed set of bounded operators on a Hilbert space is a C*-algebra, where the * operation is just the adjoint. And a special case of this is M n (C), the set of n × n complex matrices. Since it is finite dimensional, this example misses out on the subtleties associated to infinite dimensions.
We will focus on the C*-algebra description of quantum lattice systems. We start with the lattice Z d which has a finite dimensional quantum system associated to each point. Then, to each lattice site there is an associated finite dimensional C*-algebra that is equivalent to M n (C) for some n. Next we associate a finite dimensional C*-algebra A Λ to any finite region Λ of the lattice, such that A Λ is isomorphic to a tensor product of the algebras associated to each site in Λ. The C*-algebra of a subset Λ of Λ is identified with the elements in A Λ that act like the identity on Λ\Λ . So far this is similar to the usual quantum theory with a finite number of subsystems, and it would be exactly equivalent if the lattice were finite.
For any finite Λ, the norm on elements of A Λ is equivalent to the operator norm on the corresponding operators on the finite dimensional system associated to Λ.
When we consider the whole lattice Z d , the C*-algebra is a vector space that includes all elements that are non-trivial only on a finite subset of Z d . And to get the full C*-algebra, we complete this vector space, by including Cauchy sequences of elements that converge in the norm. So the total C*algebra contains local elements that are non-trivial on a finite subset of Z d and quasi local elements, which can be approximated arbitrarily well by sums of local elements.
An isomorphism is an invertible morphism. An example of an isomorphism on our quantum lattice system in the case of qubits is the conjugation of each site's algebra by X n , i.e., A → X n AX n for any A ∈ A n . It follows that the elements of the algebra associated to larger finite regions are conjugated by tensor products of Xs. Intuitively, this looks like applying the map A → XAX for any A ∈ A, where X = ⊗ m∈Z X m . Notice that X is not in the C*-algebra itself.
As mentioned above, a closed set of bounded operators on a Hilbert space is an example of a C*-algebra. Thanks to the following theorem by Gel'fand and Naimark, it is the only example.
Theorem A.0.2. Any C*-algebra is isomorphic to a C*-algebra of operators on a Hilbert space.
But the catch is that this Hilbert space may not be separable. A positive element of a C*-algebra, written as A ≥ 0, is self adjoint with a real positive spectrum. Saying an element A is positive is equivalent to saying that there exists a B ∈ A such that A = B * B. This allows us to define states on a C*-algebra.
For the C*-algebra M n (C) corresponding to an n-dimensional qudit, we can identify states with elements of M n (C), since finite dimensional vector spaces are isomorphic to their dual spaces. We recover the familiar density matrix formalism, with ρ(A) = tr[ρA], where ρ is a positive semi-definite matrix in M n (C), and tr[·] is the trace.
For our quasi-local algebra, we do not need to think in terms of abstract functionals. It is equivalent to associate a density operator to each finite subregion of the lattice. This works provided the family of states satisfies a natural consistency condition: given ρ Λ and ρ Λ are density operators associated to the finite regions Λ and Λ, with Λ ⊆ Λ, then A representation of a C*-algebra A is a morphism π from A to a set of bounded operators on a Hilbert space. A faithful representation is one where π is an isomorphism. If we have a representation π of a C*-algebra acting on the Hilbert space H, then, for any φ ∈ H, the closure of the subspace spanned by π(A)φ with A ∈ A, H φ , is left invariant by the action of all π(A). So we may as well focus on representations with H φ = H. These are called cyclic representations and φ is called a cyclic vector. Note that if we normalise φ then it defines a state on A via ω(A) = (φ, π(A)φ).
The following theorem provides the GNS construction, which allows us to construct a representation using any state on A.
Theorem A.0.4. Given a state ω on A, there exists a cyclic representation of A with a cyclic vector φ, such that ω(A) = (φ, π(A)φ).
Furthermore, this representation is unique up to unitary equivalence, meaning that, if there are two cyclic representations of A on H 1 and H 2 such that ω(A) = (φ 1 , π 1 (A)φ 1 ) = (φ 2 , π 2 (A)φ 2 ), then there is a unique unitary map U from H 1 to H 2 such that φ 2 = U φ 1 and π 2 (A) = U π 1 (A)U −1 for all A ∈ A.
The proof entails using the state to define an inner product on the C*-algebra via 19 This inner product gives us a Hilbert space with vectors A ∈ A. In particular, 1 1 ∈ A is thought of as φ, since ω(1 1A1 1) = ω(A) ≡ (φ, π ω (A)φ).
Then the representation of the elements in A as operators on this Hilbert space is simply where A is thought of as a vector here. Although mathematically we think of A ∈ A as vectors in a Hilbert space, it is also useful to think of these vectors as arising from the action of A on the state ω ≡ φ ω . A good example of a representation involves the spin lattice C*-algebra. Take ω to be the state with all spins pointing up along the z-direction, meaning ω Λ ≡ i∈Λ 1 0 0 0 (112) for all finite regions Λ. A basis for H ω is given by vectors we can think of as for all finite regions Λ. So the representation is spanned by all states with only a finite number of spins pointing down. Let us now look at automorphisms, which are just isomorphisms from the C*-algebra to itself. The following interesting result is a consequence of theorem A.0.4.
An example of an automorphism that is not implementable in a representation as a unitary is the application of Pauli Xs everywhere in the spin lattice representation given above in equation (113). This follows since flipping all the spins from up to down is not an operation that is allowed in the Hilbert space.

B QCAs with fermions
For fermionic QCAs, instead of having qudits at each site we have some number of fermionic modes. (We could also consider hybrid QCAs with both qudits and some fermion modes at each site.) The simplest way to describe fermion systems is via their creation and annihilation operators (creation operators are just adjoints of annihilation operators). A nice discussion of finite fermionic algebras is given in [93]. We denote the annihilation operators by a α , where α is a label in some set. For example, if we have a single fermion mode on each lattice site, we would take α to be a vector in Z d .
For simplicity, let us choose the index to run over Z. The creation and annihilation operators obey the anticommutation relations: Furthermore, we can construct our Hilbert space by starting with a state |0 that satisfies a α |0 = 0 (118) for all α. This state has the interpretation as being empty. The empty state also makes sense for infinite lattices of fermions, where it is defined to be a positive normalized functional ω 0 satisfying for all α. The operator a † α a α counts the number of fermions in the mode labelled by α and has eigenvalues 0 and 1. The state a † α |0 has the interpretation as having a single fermion present. Furthermore, it follows from the anticommutation relations that a †2 α = 0, which means that we can have at most one fermion in each mode.
We can also define Majorana fermion operators, which are sometimes more convenient to work with. These are defined to be These are self-adjoint and satisfy the anticommutation relations {c n , c m } = 2δ nm .
Most of the details of the quasi-local algebra approach to defining infinite systems of fermions are similar to the qudit case. We assign fermionic algebras to regions of the lattice. The main difference with the qudit case is that creation and annihilation operators from different regions or modes anticommute. See [57] for a detailed discussion.
Another way to think about fermion systems is via graded algebras. In a graded algebra we have some basis of operators with the following property: each element is either even or odd. This also extends easily to hybrid systems of qudits and fermions. For example, the fermion algebra we have already seen is a graded algebra, with, e.g., 1 1 and a † α a α being even elements whereas a α are odd. A linear combination of an even and an odd operator is neither even nor odd.
Let us take a step back and start with the graded Hilbert space H (really we mean Z 2 graded). We decompose H = H e ⊕ H o , where H o is the odd subspace and H e is the even subspace. These will correspond to the subspaces with odd and even fermion number respectively. One can also use the notation C p|q , where p and q are the dimensions of the even and odd subspaces respectively. We define even operators to be those that preserve evenness or oddness, e.g., they map even states to even states. Odd operators are then those that map the even subspace to the odd subspace and vice versa.
This leads naturally to the graded commutator. We can write this as [·, ·}, and it is defined to be bilinear and satisfy We can introduce a graded tensor product too. The tensor product of two graded Hilbert spaces is also a graded Hilbert space. A tensor product of vectors that are both even or both odd is even. A tensor product of vectors that have opposite grading is odd. So we denote the graded tensor product of H 1 and H 2 by H 1 ⊗ g H 2 . Then we have The graded tensor product of graded algebras is similar: a graded tensor product of even operators is an even operator, for example. After taking the graded tensor product of two graded algebras A and B, even elements of, e.g., A and all elements of B commute. Furthermore, we say two algebras A and B graded commute if [A, B} = 0 for all A ∈ A and all B ∈ B.