A single-shot measurement of the energy of product states in a translation invariant spin chain can replace any quantum computation

In measurement-based quantum computation, quantum algorithms are implemented via sequences of measurements. We describe a translationally invariant finite-range interaction on a one-dimensional qudit chain and prove that a single-shot measurement of the energy of an appropriate computational basis state with respect to this Hamiltonian provides the output of any quantum circuit. The required measurement accuracy scales inverse polynomially with the size of the simulated quantum circuit. This shows that the implementation of energy measurements on generic qudit chains is as hard as the realization of quantum computation. Here a ''measurement'' is any procedure that samples from the spectral measure induced by the observable and the state under consideration. As opposed to measurement-based quantum computation, the post-measurement state is irrelevant.


Introduction
The characteristic feature of quantum systems is the abundance of mutually incompatible observables. According to the axioms of standard quantum mechanics [19] every self-adjoint operator on the system Hilbert space defines a physical variable that could in principle be measured (the richness of observables even increases if one considers generalized observables, defined by positive operator-valued measures [9]). In particular, for systems that are composed of many components it is by no means obvious how to measure an arbitrary observable given its description as a Hilbert space operator.
In recent years, quantum information processing has shown how one could in principle design arbitrarily complex unitary transformations by concatenating elementary operations [10]. Given that a measurement procedure for one maximally abelian observable is available, such unitary transformations would allow us to measure every self-adjoint operator by transforming it into a function of the former. Moreover, it has been recognized that the so-called quantum phase-estimation procedure can be used to measure self-adjoint observables [30,27,13]. Insights of this kind raise the question of which types of observables are easy to measure and which ones require complex transformations to reduce them to observables for which measurement procedures are known. Even if we specify a set of elementary observables and a set of elementary unitary transformations, it is a difficult task to find lower bounds on the required control operations. The close relation to tasks of quantum information processing suggests to address this question from a different point of view: Instead of trying to find such lower bounds (which are also hard to get for computational problems) one should rather try to place the question of the hardness of certain measurements in the context of complexity theory. This will be done in the present paper by showing that the implementation of certain measurements would already make it possible to solve classically hard computational problems.
The computational power of quantum measurements has extensively been explored in recent years since models for quantum computations have been described that are solely based on measurements [6,7,25]. However, these models require either concatenations of measurements [7] or the preparation of an entangled initial state [25]. In contrast, it has been shown in [30] that accurate measurements can even solve computational PSPACE-complete problems when applied to computational basis states [30]. This statement requires a high measurement accuracy allowing one to resolve the exponentially small spectral gaps that are typical for interactions in many-particle systems. Therefore, this result should be understood as exploring complexity-theoretic limitations on the measurement accuracy that can be achieved. It should not be interpreted in the sense that all (i.e., even less accurate) measurements of these observables are also difficult.
Based on the constructions in [30], it was shown in the unpublished work [29] that one obtains the computational complexity class BQP instead of PSPACE if the required measurement accuracy is only inverse polynomial instead of exponential in the number of particles. More precisely, it was proved that a measurement instrument is a full BQP-oracle if it is able to measure so-called k-local observables when the system is in an appropriate basis state 1 . Here and in the following the term "basis state" is used in the sense of a previously determined basis consisting of product states in the many-particle system.
Here we tighten the results of [29] in four respects. First, we show that k-locality can be replaced with finite range interactions in one-dimensional chains. Second, we can restrict the attention to translationally invariant operators. Self-adjoint operators of this kind are closer to Hamiltonians of real physical systems. Consequently, both modifications increase thus the physical relevance of the result: measurements of the observable "energy", i.e., the Hamiltonian H of a system plays a central role in understanding its physics as the spectrum of the Hamiltonian determines the dynamical and thermodynamical behavior. Third, we do not need a measurement apparatus for a general translationally invariant Hamiltonians. Instead, it suffices in present setting to measures just one specific observable that is universal. Fourth, we need only a single-shot measurement instead of repeated measurements.
The idea of the construction is as follows. First of all we construct a Hamiltonian H that encodes a one-dimensional quantum cellular automaton. In analogy to the constructions in [11,23,22,15,14,28], the time-evolution exp(−iHt) leads to superpositions between different time-steps and also between time-steps in a backward-time computation instead of implementing the computation step by step. Then we assume that we are given an arbitrary quantum circuit that computes the result (YES, NO) of a computational problem when applied to an appropriate basis state (with respect to an a priori chosen product basis). Since the cellular automaton is universal for quantum computing, we can chose an initial basis state such that it simulates the quantum circuit. In other words, the program for the computation and the classical input data are encoded into the basis state. Due to our specific construction of H, the spectrum of its restriction to the smallest invariant subspace containing the initial state depends on the result of the simulated quantum circuit. Since we have ensured that the two spectra corresponding to the solutions YES and NO are disjoint we obtain the answer by measuring only once.
It should be emphasized that we obtain the result of the computation by applying measurements to the initial state which is a basis state encoding program and data. The following argument describes in a metaphoric way why this is possible. We construct H in such a way that the computation process stops at the end of the computation whenever the output is negative. Otherwise it continues with performing a large number of idle operations. Whether or not the computation process stops is certainly relevant for the spectrum of the restriction of H to the smallest H-invariant subspace containing the initial state. We choose the number of idle steps in such a way that the spectra become mutually disjoint. Then we can check the result of the computation by a single-shot measurement of the energy applied to the initial state.

Defining measurements and their accuracy
Our complexity theoretic results heavily rely on the definition of what it means to measure an observables with a certain accuracy. Following standard definitions in quantum mechanics [19], we define a quantum transformation to be a measurement of the observable A if its application to an arbitrary state ρ generates eigenvalues λ j of A as outcomes such that tr(ρQ j ) is the probability of obtaining λ j , where A = j λ j Q j is the spectral decomposition of A. In other words, an A-measurement (applied to the state ρ) allows us to sample from the spectral measure induced by the operator A and the state ρ. Since the measurement accuracy is relevant for the implementation complexity (compare [30]) we need a precise definition of the accuracy.
Before formally introducing approximative measurements, we point out that a process generating outcomes whose expected value coincides with tr(ρA) is not sufficient for our purposes. The ability to implement measurement of the latter type is certainly a much weaker assumption. Consider, for instance, a Hamiltonian H of the form where each H j is an operator acting on k adjacent particles only. Then we can reproduce the expected value tr(ρH) = 1 n j tr(ρ(n H j )) by choosing a value j randomly (according to the uniform distribution) and implementing a measurement for n H j (requiring the ability to control only a small subsystem of the quantum system).
We now define an approximative measurement: We emphasize that our definition of approximate measurements focuses only on the measurement outcomes and not on the post-measurement states that are irrelevant.
It is known that the time evolution exp(−iAt) can efficiently be simulated for all k-local operators 2 A acting on n-qubits in the following sense: a unitary U t with U t − exp(−iHt) ≤ θ can be implemented with resources that are only polynomial in 1/θ, n, and t [5,4,2]. For k-local operators on n qudits one has to introduce elementary operations on such a system (e.g. those involving only two qudits) in order to define an appropriate notion of complexity.
It was shown how to realize approximate A-measurements using the quantum phase estimation procedure using approximations V of U := exp(−iA/ A ) for appropriate t [30,16]. A measurement with maximal error δ and reliability 1 − ǫ in our sense can be achieved using only resources polynomial in 1/δ, 1/ǫ, and n. This follows by adapting the arguments of [30,16,17,18] to the above definition of reliability and accuracy.
Roughly speaking, this result means that the realization of quantum computation is at least as hard as the implementation of approximate measurements of k-local observables. The results of [29] can be interpreted as the converse statement saying that the implementation of k-local measurements is at least as hard as the realization of quantum computation. To be more precise, [29] showed that repeated k-local measurements can solve all problems in the complexity class PromiseBQP (i.e., the class of problems that can be solved by the quantum computer in polynomial time by a probabilistic algorithm) and the required measurement accuracy is polynomial in the running time of the simulated circuit. The present work shows that approximate measurements of physically more relevant Hamiltonians (translationally invariant finite-range interactions on qudit chain) can also solve all problems PromiseBQP. Before proving this, we give the formal definition of PromiseBQP.

Quantum computation as approximate energy measurement
The complexity class BQP is usually considered to represent the class of problems that can be solved efficiently on a quantum computer. However, it is often necessary to consider a generalization of this complexity class given by the promise version of BQP. For example, if we want to study complete problems (i.e., problems that fully capture the power of quantum computing) then we have to work with PromiseBQP since BQP is not known to contain complete problem (just as its classical counterpart BPP and other semantic complexity classes such as MA). For these reasons, we work with PromiseBQP.
BQP is the class of language recognition problems that can be solved efficiently on a quantum computer. A language recognition problem is to decide whether a given string x is an element of a language L ⊆ {0, 1} * or not. The essential point is that a language defines a partition of the set of all strings into those that belong to L and those belonging to the complement of L and that the quantum computer must be able to decide whether x ∈ L and x ∈ L for every x. The promise version of a complexity class can also contain decision problems that do not correspond to language recognition problems. Given a set of allowed inputs Π := Π YES ∪ Π NO , the problem is to decide whether x ∈ Π YES or x ∈ Π NO given the promise that x ∈ Π (note that language recognition problems are promise problems where Π is the set of all strings). We denote this problem by (Π YES , Π NO ). Observe that the problem of deciding if x is in Π could be computationally much harder.
The formal definition of PromiseBQP is: PromiseBQP is the class of promise problems that can be solved by a uniform 3 family of quantum circuits (U (n) ). More precisely, it is required that this family of quantum circuits U (n) decides if a string x of length n is a YES-instance or NO-instance in the following sense. The application of U (n) to the computational basis state |x, 0 produces the state such that Equation (1) has to be read as follows. The input string x determines the first n qubits. The remaining a = poly(n) additional ancilla qubits are initialized to |0 . After U (n) has been applied we interpret the first qubit as the relevant output; the remaining n + a − 1 output values are irrelevant. The number of the gates of the circuit U (n) is r = poly(n).
Definition 2 clarifies the notion of an "efficient quantum algorithm". The following theorem is the main result of the paper. It states that efficient quantum algorithms can be simulated by energy measurements whose accuracy in the sense of Definition 1 is inverse polynomial in the length of the simulated circuit, where the Hamiltonian is a finite-range translationally invariant Hamiltonian on a one-dimensional qudit chain and the initial state is a canonical basis state. The proof of the theorem follows from the construction of the Hamiltonian in Section 5 using some general spectral analysis developed in the following section, phrased as Lemma 1 and Lemma 2.

Theorem 1 There is a family of Hamiltonians
such that energy measurement of the Hamiltonians H (m) in canonical basis states with maximal error δ = 1/poly(m) and reliability 1 − ǫ can probabilistically solve Promise-BQP in the following sense: Let U (n) be a family of quantum circuits that solve a problem in PromiseBQP as in Definition 2. Then for all input strings x of length n, there is a partition R = Y m∪ N m , and a computational basis state |ψ x ∈ (C 56 ) ⊗m such that where λ is the random variable defined by the energy measurement of H (m) in the state |ψ x and m = poly(n). The quantities m, |ψ x , Y m , and N m can be efficiently computed from x and U (n) .

Spectral requirements on the Hamiltonian
We start with Hamiltonians that are not necessarily of the special form in eq. (2). This relaxation allows us to provide a simpler and more intuitive understanding of why accurate energy measurement can solve PromiseBQP-problems at all. We construct a suitable finite-range translationally invariant Hamiltonian on a qudit chain in Section 5.
We now briefly review the basic principles of the autonomous Hamiltonian computers proposed by Benioff, Feynman, and Margolus [3,11,23] since our Hamiltonian can be view as a special type of an autonomous Hamiltonian quantum computer. Originally, the construction of computational models in terms of autonomous Hamiltonian dynamics of closed physical systems was motivated, among others, by the study of thermodynamics of computation. Kitaev observed that these ideas are also useful in quantum complexity theory since they provide a connection between problems of determining spectral properties of Hamiltonians and those of finding solutions of hard computational problems. This link has mainly been used in the context of the proof the QMA-completeness of the so-called local Hamiltonian problem (estimating the ground state energy for a wide range of Hamiltonians [22,20,21,26,1]).
Let U = U r U r−1 · · · U 1 be a quantum circuit consisting of the elementary gates U t acting on the logical Hilbert space H for t = 1, . . . , r. We adjoin a Hilbert space H clock that represents the clocking device of the autonomous computer and define on H ⊗ H clock the "forward time operator" where we have used the convention U t = 1 for t ∈ {1, . . . , r}. The states |t label some states in H clock and represent the time steps of the quantum circuit U . They do not necessarily span the whole space H clock . We then define a Hamiltonian by Applying the time evolution exp(−iHt) to the state |x, 0 ⊗ |0 leads to superpositions of states of the form The idea of Hamiltonian computers is then to initially prepare the clock in a superpsoition of states with negative t in such a way that the wave packet propagates mainly in forward direction and triggers the implementation of gates.
The reason why such models of autonomous computation can only simulate quantum circuits in such a "broader sense" (i.e., one has always superpositions of different computational states) is that the Hamiltonians should be k-local for some small constant k. It is not known how to directly implement unitary operations U by timeindependent Hamiltonians H of this type where U = exp(−iH) represents some interesting computation.
An important feature of the forward-time operators in the above mentioned literature is that they act unitarily on the relevant subspace of "computational states" This makes a spectral analysis feasible since F and F † commute on this subspace.
For our construction, we do not want the Hamiltonian really to perform the computation in the above sense. However, the above explanation still remains the leading intuition. To prove that approximate energy measurements can solve PromiseBQPproblems, we have to introduce a modification of the above forward-time operator such that it is no longer unitary on the relevant subspace and analyze its spectral properties. We need the read-out gate R := |1 1| and the annihilation gate A := 0 (where 0 is the zero matrix) for this modification. Let U = U r U r−1 . . . U 1 be a quantum circuit as above and let s be greater than r. We construct a non-unitary quantum circuitÛ =Û s+1ÛsÛs−1 · · ·Û r+1ÛrÛr−1 · · ·Û 1Û0 where its elementary gates are defined as followŝ The reader may be confused thatÛ is just the trivial operator 0. The reason why we define such an unusual "quantum circuit" is that this definition allows us to interpret every operation performed by the forward time operator, including state annihilation, as a (not necessarily unitary) quantum "gate". Then we construct a modified forward time operator (compare eq. (5)) by To intuitively understand why the spectral measure of the Hamiltonian H := F +F † will then reflect the solution of the computational problem we observe the following. Assume we apply the time evolution exp(−iHt) to the state |x, 0 ⊗ |1 and the answer of the problem is "YES" with probability 1. In this case the orbit exp(−iHt)(|x, 0 ⊗ |1 ) t∈R + consists of superpositions of the states F t (|x, 0 ⊗ |1 ) for t = 0, . . . , s. This is because F † and F annihilate the first and the last state in this set, respectively, and on the remaining states (i.e. t = 0, . . . , s − 1) they commute since the non-unitary readout gate is irrelevant. The dynamics is then mathematically equivalent to a particle moving on a chain of length s + 1 (with a dynamics induced by "hopping terms").
If the answer is "NO" with probability 1 the dynamics is restricted to the subspace spanned by F t (|x, 0 ⊗ |1 ) for t = 0, . . . , r, i.e., a dynamics on a chain of length r + 1.
In the generic case the answer is non-deterministic and we obtain a mixture of both cases such that probability distribution of the results of a H-measurement depends directly on the outcome probabilities of the simulated circuit. For the mathematical analysis of this case we will use the decomposition where |ψ 1 is obtained by renormalizing (F † ) r+1 F r+1 (|x, 0 ⊗ |1 ) and |ψ 0 by renormalizing |x, 0 ⊗ |1 − (F † ) r+1 F r+1 (|x, 0 ⊗ |1 ). These components correspond to new initial states for which the answer in the readout step is deterministic. The following lemma specifies precisely the statement and the conditions on F that we require.
Lemma 1 Let U = U r U r−1 · · · U 1 be a quantum circuit that accepts the state |x, 0 with probability p x,1 in the sense of Definition 2. LetÛ =Û s+1Ûs · · ·Û 0 be the corresponding non-unitary quantum circuit as defined in eqs. (6) to (10 for t = 0, . . . , s on the smallest F and F † invariant subspace containing the initial state |ψ := |x, 0 ⊗ |1 . Then the spectral measure induced by F + F † and the initial state |ψ is given by the convex combination where P ℓ denotes the spectral measure induced by the adjacency matrix of the line graph with ℓ vertices (for ℓ = r + 1 and ℓ = s + 1) and the first basis vector |0 . To be more explicit, the adjacency matrix is given by where S ℓ denotes the non-cyclic shift in ℓ dimensions with the canonical basis vectors |0 , |1 , . . . , |ℓ − 1 , i.e., Let λ v be the vth eigenvalue of L ℓ and Q (ℓ) v be the corresponding spectral projection. Then P ℓ is the probability distribution on the eigenvalues defined by Proof: Let |ψ 1 be the vector obtained by renormalizing the vector and |ψ 0 by renormalizing |ψ − (F † ) r+1 F r+1 |ψ . Let V 0 be the span of {F t |ψ 0 } j=0,...,r and V 1 the span of {F t |ψ 1 } j=0,...,s . The statement V 0 ⊥ V 1 follows from the fact that holds for all t = t ′ , because the states then correspond to different basis vectors in the clock space. For t = t ′ = r the restrictions of the states F t |ψ 1 and F t |ψ 0 to the data register are given by renormalizing RU r · · · U 1 |ψ and (1 − R)U r · · · U 1 |ψ , respectively. For 0 ≤ t ≤ r − 1 we have to apply the unitary operator U † t+1 · · · U † r to both states in eq. (14), which obviously preserves the orthogonality relation.
One easily checks that V 0 and V 1 are invariant under the action of F and F † . This implies that they are also invariant under F + F † .
We first determine the spectral measures induced by |ψ 0 and |ψ 1 . On V 0 the operator F is unitarily equivalent to the non-cyclic shift S r+1 by identifying the orthonormal basis vectors F t |ψ 0 with the basis vectors |t ∈ C r+1 for t = 0, . . . , r. This unitary equivalence is readily verified by checking that F maps the tth basis vector to the (t + 1)th for t < r and annihilates F r |ψ 0 . Hence the spectral measure induced by F + F † on |ψ 0 is the same as the spectral measure induced by L r = S r+1 + S † r+1 on |0 , i.e., it is equal to P r+1 .
The lemma shows how to construct a Hamiltonian H = F + F † such that the distribution of the results in an accurate measurement is given by the measure (1 − p x,1 )P r+1 + p x,1 P s+1 as in Lemma 1. To analyze how to assign measurement outcomes with "YES" and "NO" we recall that the spectrum of the line graph L ℓ of length ℓ is given by the values . . , r} be the spectrum of the line graph L r+1 and S s+1 := {µ w : w = 0, . . . , s} that of L s+1 . If r + 2 and s + 2 are relatively prime, then S s+1 and S r+1 are disjoint. This assumption is useful since it will allow us to replace the quantum computation with a single shot measurement instead of repeated sampling. To obtain a lower bound on the distance between these two sets we apply the function x → arccos(x/2)/π to the eigenvalues λ v and µ w and obtain the values The minimal distance between any of these values is at least 1/(r + 2)(s + 2). On the interval [0, π] the cosine function satisfies the inequality for all x, y with |x − y| ≤ 1. These facts imply that the minimal distance between the spectra S r+1 and S s+1 is at least ∆ := π 2 2(r + 2) 2 (s + 2) 2 .
From an intuitive point of view, this already shows that the ability to implement measurements with inverse polynomial error makes it possible to assign a measurement outcome to either of the two spectra. The following lemma bases this statement on the formal definition of measurement accuracy and analyzes the probability of correctly classifying the input. It follows immediately from the arguments above.

Lemma 2 Let the distribution of measurement results in an accurate measurement be given by
with q ∈ [0, 1], where P ℓ for ℓ = r + 1, s + 1 denotes the spectral measure of the line graphs of length ℓ as above. Assume we have an approximative measurement procedure with accuracy ∆ as in eq. (15) and reliability 1 − ǫ. For δ := ∆/3 define where µ w denotes the wth eigenvalue of the line graph of length s + 1. Let λ be the measurement outcome. Then we have the conditional probabilities The lemma shows that the error of the measurement-based decision procedure then essentially reproduces the error probabilities of the simulated circuit provided that the probability to have an error greater than ∆ is small. The arguments in this section thus establish that energy measurements for local Hamiltonians can be used to solve PromiseBQP-problems. Here "local" means that the interaction involves only a few, but not necessarily adjacent, qubits (if we represent the clock also by a qubit register). Unfortunately, this does not suffice to prove Theorem 1 because we have not described how to construct a nearest-neighbor translationally invariant interaction H on a qudit chain having the desired properties. In the next section, we show how to construct such interaction based on a quantum cellular automaton (QCA) in such a way that it still satisfies the spectral properties in Lemma 1. Our interaction is not supposed to be the simplest operator satisfying all the above requirements. However, we have chosen an encoding of quantum circuits that seems to be rather concise and quite natural. It is likely that more sophisticated encodings could significantly reduce the size of the unit cell of the QCA.

Construction of the Hamiltonian
To construct the QCA, we restrict ourselves to the following universal set of quantum gates. Let S denote the swap gate and W the controlled gate defined by We require that both gates be only applied to adjacent qubits. Moreover, we require that W be applied only in one direction, i.e., the control-wire will always be the left qubit of the corresponding pair. This set of gates is universal because the W gate is universal if it can be applied to arbitrary qubit pairs [24]. We assume without loss of generality that the quantum circuits U in Definition 2 are composed only of S and W acting on adjacent qubits. We also assume that gates acting on disjoint qubit pairs can be performed in parallel. In this way, the quantum circuits are split into layers.
We refer to these layers as the time steps of the quantum circuit.

Description of our quantum cellular automaton
We now construct a quantum cellular automaton (QCA) that can simulate any such quantum circuit such that the total number of time steps required is polynomial in the number of gates and the number of qubits used in the simulated circuit. We encode the quantum circuit and its input in the initial state of the QCA. It acts on where H c := C 56 denotes the Hilbert space of a single cell. Our Hamiltonian has the form where V acts on two cells, i.e., on H c ⊗ H c . Each cell consists of a data and a program cell, i.e., we have where H p and H d denote the Hilbert space of the program and data cell, respectively. We refer to the set of all program cells (i.e., H ⊗m p ) as the program band and to that of all data cells (i.e., H ⊗m d ) as the data band. The program band initially contains the description of the quantum circuit U to be simulated. We refer to this description as the program code. This code is divided into blocks where each block corresponds to one time step of U . The data register is a subset of the data band that corresponds to the register on which U acts, i.e., it represents the logical qubits. The remaining part of the data band will only contain formatting symbols.
The The program code is composed of the gate symbols I, S, W, R, and A. These symbols correspond to the identity, S, W , R, and A, respectively. The marked gate symbols I, S, W, R, and A are used to control the propagation of the program code. The symbols , , 3, and # are also used for this purpose. We refer to these symbols as the hole, execution, turn-around, and blank symbols, respectively. The kets |0 and |1 correspond to the two orthogonal states of a qubit. The symbols and • are used for |x W S |0 R E Figure 1: Example of a simple quantum circuit that acts on 2 qubits and consists of 5 time steps. The first qubit takes the input is x. The second qubit is an ancilla qubit. Figure 2: Initialization of the program and data bands formatting purposes; the symbol makes it possible to determine when the program has been moved by one block. They are contained only in those data cells that do not belong to the data register.
During the dynamics the content of the program cells slides over the data cells and triggers the implementation of the gates on the data register. Since we want to construct a nearest neighbor interaction the sliding of the program can only be realized by moving the content cell by cell. Therefore, we need a special control mechanism that ensures that the program is only executed after it has been moved by exactly one block, i.e., the block is again aligned with the corresponding data cells on which the gates are supposed to act. The forward time operator F in eq. (18) must implement the propagation and the execution of the gates whenever the program is aligned with the data band.
The operator V in eq. (18) is thus the product where X applies gates on H d ⊗ H d conditioned on the state of H p ⊗ H p and T realizes transitions between basis states of H p ⊗ H p . Before we define T and X explicitly we look at a simple example to see how quantum circuits and inputs are encoded in the initial states. We also explain how the execution of the program code is controlled in a purely local procedure where no global clocking is available.
1. Assume we want to simulate the circuit in fig. 1. Then we initialize the program and data bands as shown in fig. 2. The program code is A W IIS IIR IIA I, where the gaps are used to indicate the different time steps of the quantum circuit U . All other program cells contain the blank symbol #. Note that the two qubit gates W and S are encoded by symbol pairs IW and IS, respectively, and that the program contains an extra symbol I between the blocks (i.e., the layers of the circuit) and the first command of the program reads A. In the initial state, the first layer of the circuit is aligned with the data register that is initialized in the state |x, 0 . The symbols to the left and right of the data register enclose exactly two • symbols, corresponding to the number of qubits of U .
2. It is important that the program code starts with the pair A . One may rather expect the initial configuration A, but this would lead to an execution of A in the first step. This is analogous to Section 4, where we have to start in the clock state |1 instead of |0 to prevent the execution of the first annihilation gatê U 0 := A. The purpose of this choice of the initial state is to ensure that it is annihilated by the operator F † because it implements the program in backward direction. The execution symbol is propagated cell by cell to the end of the program code until it arrives at the rightmost cell not containing the blank symbol #. In each step, and the gate symbol G on its right side swap their positions. More precisely, if is in the jth program cell and G in the (j + 1)th cell, then G moves to the jth cell and to the (j + 1)th cell. While swapping the symbols, the gate corresponding to G is executed. It is applied to data cells j and j + 1 if it is a two qubit gate and to data cell j + 1 if it is a single qubit gate. This only happens only if the data cell j and data j + 1 are inside the data register in the case of a two qubit gate. Similarly, it only happens if the data cell j + 1 is inside the data register in the case of a singe qubit gate.
3. Once the execution symbol has passed the end of the program code it is converted to the blank symbol # (via the creation of the intermediate turn-around symbol 3) and a signal is sent to the begin of the program code. This signal indicates that the execution of the first time step of the program code has been completed. To avoid that the propagation of this signal leads to a backward propagation of the program code the signal cannot occupy a program cell on its own. It propagates by converting each gate symbol G into a marked version G cell by cell. Once the marked gate symbol G is at the begin of the program code it is converted into the hole symbol symbol via the creation of the turn-around symbol 3.

The hole symbol
propagates cell by cell to the end of the program where it is converted to the blank symbol # and triggers the left propagating marker G (via the creation of the intermediate turn-around symbol 3). The arrival of this marker at the begin of the program code triggers the conversion of the next copy of # into . This procedure is repeated until the begin of the program code is again aligned with the next copy of the format symbol in the data band. In this case, the marker G triggers the creation of instead of and the whole cycle starting in the second step is repeated (again, this is done by the creation of the intermediate turn-around symbol 3).
The above procedure is implemented by the following nearest-neighbor transition rules. These rules depend only on the contents of two adjacent cells of the QCA. We use * to denote any of the symbols 0, 1, and •. The symbol represented by * is left unchanged by the corresponding transition rule. In the transition rules 2 and 6 the left lower and right lower corners are left empty to indicate that the symbol at that place is not important for the transition rule and that it is left unchanged.
Transitions 1 a) and b) implement the rightward propagation of the symbols and , respectively. Transitions 2 a) and b) takes place when and have passed the end of the program code, respectively. They create the symbol 3 (turn-around). Transition 3 creates a marked gate symbol that initiates the leftward moving signal. Transition 4 implements the propagation of this signal. Once this signal has arrived at the begin of the program code, transition 5 and transitions 6 a) and b) create the symbols and via the creation of the intermediate turn-around symbol 3, respectively. The execution symbol is created only if the turn-around symbol 3 is exactly above the formatting symbol , which happens only if the blocks of the program code are aligned with the data register. Otherwise, the hole symbol is created. Now we are ready to define the transition operator T . It is the annihilation-creation operator on H c ⊗ H c defined by all the above transition rules. It annihilates all configurations that do not appear on the left-hand side of any of the above transitions.
We denote by X the operator that realizes the controlled execution of the gates. It is defined by where

Spectral properties
We denote the initial state of the QCA by |x, 0 ⊗ |1 where |x, 0 is the initial state of the quantum circuit to be simulated and |1 represents the state of the program band and the state of all data cells outside the data register that corresponds to an appropriately chosen initial configuration.
The application of F changes the configuration in the program cells into a new basis state and applies, at the same time, gates to the relevant section in the data cells. This is because the transition rules are designed such that only one transition is possible in each step provided that the initial configuration has been chosen as described in the preceding section. We can thus denote the configurations as the clock states |1 , |2 , . . . . Since our simulation of the original circuit contains not only execution steps but also operations where only signals are propagated the circuit is thus extended by polynomial overhead of identity gates on the data cells. We thus haves + 1 steps instead of s + 1 until the state is completely annihilated. Likewise, the readout gate causes a conditional annihilation in the stepr + 1 instead of r + 1.
To make sure that F and the initial state |x, 0 ⊗ |1 satisfy the conditions of Lemma 1 we have to check that the application of F † to one of the states in the orbit F t (|x, 0 ⊗ |1 ) with t = 1, . . . ,s indeed leads to the preceding clock state and to an annihilation for t = 0. The annihilation property is satisfied since we have started the system in a state where the running of the program in backward direction would immediately execute the A gate. To see that F † leads in the general case to the preceding states, we have to check our list of transitions in backward direction.
Every configuration that arises from the repeated application of the forward-time operator F always contains exactly one element in the set { , , 3, I, S, W}. If the configuration contains one of the symbols and but they are neither preceded nor followed by the blank symbol # (i.e., they are not located at the boundaries of the program code), then only rule 1 a) or b) can be active in the backward direction. The pattern in rule 2 only occurs when the symbols or are located at the right boundary of the program code. In this case, no other rules are active in the backward direction. Similarly, the pattern in rule 6 only occurs when the symbols or are located at the left boundary of the program (i.e., only when they are preceded by #). In this case, no other rule is active in the backward direction.
The symbol 3 only appears in rules 2 and 5 on the right hand side of the transitions. But there is no configuration where both rules can be applied backwards at the same time. Likewise, the marked gate symbols only occur in rules 3 and 4. Again, there is no configuration where both rules can be applied backwards at the same time.
Hence we have shown that F meets the requirements of Lemma 1 and that the spectral measure induced by F + F † on the initial state |x, 0 ⊗ |1 depends on the acceptance probability p x,1 . To design a program code such that the supports of the two corresponding spectral measures to be distinguished are disjoint we may choose the position of the annihilation gate appropriately. In this way we can always achieve thatr + 2 ands + 2 are relatively prime, ensuring that the minimal distance between the supports of the spectra satisfies eq. (15).

Conclusions
In contrast to usual measurement-based approaches to quantum computing we have constructed an observable whose measurements have full quantum computation power when applied to a basis state only once. The required accuracy scales inverse polynomially with the number of gates of the simulated quantum circuit.
The observable is a Hamiltonian of a finite-range interaction with translation symmetry. Even though our specific construction is unlikely to be found in real physical systems our result strongly suggests that energy measurements for real physical systems is a task whose realization is as challenging as the realization of quantum computing. This shows, once more, that quantum information processing in a broader sense is not only required to solve computational problems. Instead, it is a task that occurs already in the context of usual quantum control. Since we have shown in a previous paper that more accurate measurements of observables of a similar type solve all problems in the complexity class PSPACE our result can also be interpreted as showing how the complexity of quantum control procedures depend on the demanded accuracy.