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

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

Abstract

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.

1 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 -local observables when the system is in an appropriate basis state1. 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 -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 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 that encodes a one-dimensional quantum cellular automaton. In analogy to the constructions in [11, 23, 22, 15, 14, 28], the time-evolution 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 , 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 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 to the smallest -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.

2 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 if its application to an arbitrary state generates eigenvalues of as outcomes such that is the probability of obtaining , where is the spectral decomposition of . In other words, an -measurement (applied to the state ) allows us to sample from the spectral measure induced by the operator 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 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 of the form

where each is an operator acting on adjacent particles only. Then we can reproduce the expected value by choosing a value randomly (according to the uniform distribution) and implementing a measurement for (requiring the ability to control only a small subsystem of the quantum system).

We now define an approximative measurement:

Definition 1 (Measurement accuracy)


A measurement of the observable is said to have maximal error and reliability if the following condition holds: The probability of obtaining an outcome in the interval is at least for every interval and every state , where denotes the spectral projection of corresponding to the eigenvalues in .

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 can efficiently be simulated for all -local operators2 acting on -qubits in the following sense: a unitary with can be implemented with resources that are only polynomial in , , and [5, 4, 2]. For -local operators on 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 -measurements using the quantum phase estimation procedure using approximations of for appropriate [30, 16]. A measurement with maximal error and reliability in our sense can be achieved using only resources polynomial in , , and . 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 -local observables. The results of [29] can be interpreted as the converse statement saying that the implementation of -local measurements is at least as hard as the realization of quantum computation. To be more precise, [29] showed that repeated -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.

3 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 is an element of a language or not. The essential point is that a language defines a partition of the set of all strings into those that belong to and those belonging to the complement of and that the quantum computer must be able to decide whether and for every . 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 , the problem is to decide whether or given the promise that (note that language recognition problems are promise problems where is the set of all strings). We denote this problem by . Observe that the problem of deciding if is in could be computationally much harder.

The formal definition of PromiseBQP is:

Definition 2 (PromiseBQP)


 PromiseBQP is the class of promise problems that can be solved by a uniform3 family of quantum circuits . More precisely, it is required that this family of quantum circuits decides if a string of length is a YES-instance or NO-instance in the following sense. The application of to the computational basis state produces the state

(1)

such that

  1. for all and

  2. for all (or equivalently, that ).

Equation (1) has to be read as follows. The input string determines the first qubits. The remaining additional ancilla qubits are initialized to . After has been applied we interpret the first qubit as the relevant output; the remaining output values are irrelevant. The number of the gates of the circuit is .

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

(2)

acting on , where acts on and defines an embedding by

such that energy measurement of the Hamiltonians in canonical basis states with maximal error and reliability can probabilistically solve PromiseBQP in the following sense:

Let be a family of quantum circuits that solve a problem in PromiseBQP as in Definition 2. Then for all input strings of length , there is a partition , and a computational basis state such that

(3)
(4)

where is the random variable defined by the energy measurement of in the state and . The quantities , , , and can be efficiently computed from and .

4 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 be a quantum circuit consisting of the elementary gates acting on the logical Hilbert space for . We adjoin a Hilbert space that represents the clocking device of the autonomous computer and define on the “forward time operator”

(5)

where we have used the convention for . The states label some states in and represent the time steps of the quantum circuit . They do not necessarily span the whole space . We then define a Hamiltonian by

Applying the time evolution to the state leads to superpositions of states of the form

and

The idea of Hamiltonian computers is then to initially prepare the clock in a superpsoition of states with negative 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 -local for some small constant . It is not known how to directly implement unitary operations by time-independent Hamiltonians of this type where 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” spanned by and with . This makes a spectral analysis feasible since and 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 PromiseBQP-problems, 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 and the annihilation gate (where is the zero matrix) for this modification. Let be a quantum circuit as above and let be greater than . We construct a non-unitary quantum circuit

where its elementary gates are defined as follows

(6)
(7)
(8)
(9)
(10)

The reader may be confused that is just the trivial operator . 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 will then reflect the solution of the computational problem we observe the following. Assume we apply the time evolution to the state and the answer of the problem is “YES” with probability . In this case the orbit

consists of superpositions of the states for . This is because and annihilate the first and the last state in this set, respectively, and on the remaining states (i.e. ) 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 (with a dynamics induced by “hopping terms”).

If the answer is “NO” with probability the dynamics is restricted to the subspace spanned by for , i.e., a dynamics on a chain of length .

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 -measurement depends directly on the outcome probabilities of the simulated circuit. For the mathematical analysis of this case we will use the decomposition

where is obtained by renormalizing and by renormalizing . 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 that we require.

Lemma 1

Let be a quantum circuit that accepts the state with probability in the sense of Definition 2. Let be the corresponding non-unitary quantum circuit as defined in eqs. (6) to (10). Let be an operator acting on where stands for “data space” and for “clock space”, respectively. Let denote some mutually orthogonal states of the clock register. Assume that and act as

(11)
(12)

for on the smallest and invariant subspace containing the initial state .

Then the spectral measure induced by and the initial state is given by the convex combination

where denotes the spectral measure induced by the adjacency matrix of the line graph with vertices (for and ) and the first basis vector . To be more explicit, the adjacency matrix is given by

where denotes the non-cyclic shift in dimensions with the canonical basis vectors , i.e.,

Let be the th eigenvalue of and be the corresponding spectral projection. Then is the probability distribution on the eigenvalues defined by

Proof: Let be the vector obtained by renormalizing the vector

and by renormalizing . Let be the span of and the span of . The statement follows from the fact that

(13)

holds for all , because the states then correspond to different basis vectors in the clock space. For the restrictions of the states and to the data register are given by renormalizing

(14)

respectively. For we have to apply the unitary operator to both states in eq. (14), which obviously preserves the orthogonality relation.

One easily checks that and are invariant under the action of and . This implies that they are also invariant under .

We first determine the spectral measures induced by and . On the operator is unitarily equivalent to the non-cyclic shift by identifying the orthonormal basis vectors with the basis vectors for . This unitary equivalence is readily verified by checking that maps the th basis vector to the th for and annihilates . Hence the spectral measure induced by on is the same as the spectral measure induced by on , i.e., it is equal to .

Similarly, induces the spectral measure on . The spectral measure induced by is then just the convex sum of the measures induced by and , respectively. By elementary linear algebra, the corresponding weights are and . This completes the proof.

The lemma shows how to construct a Hamiltonian such that the distribution of the results in an accurate measurement is given by the measure as in Lemma 1. To analyze how to assign measurement outcomes with “YES” and “NO” we recall that the spectrum of the line graph of length is given by the values

for [8]. Let be the spectrum of the line graph and that of .

If and are relatively prime, then and 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 to the eigenvalues and and obtain the values

The minimal distance between any of these values is at least . On the interval the cosine function satisfies the inequality

for all with . These facts imply that the minimal distance between the spectra and is at least

(15)

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 , where for 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 . For define

where denotes the th eigenvalue of the line graph of length . Let be the measurement outcome.

Then we have the conditional probabilities

(16)
(17)

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 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.

5 Construction of the Hamiltonian

To construct the QCA, we restrict ourselves to the following universal set of quantum gates. Let denote the swap gate and the controlled gate defined by

We require that both gates be only applied to adjacent qubits. Moreover, we require that 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 gate is universal if it can be applied to arbitrary qubit pairs [24]. We assume without loss of generality that the quantum circuits in Definition 2 are composed only of and 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.

5.1 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 denotes the Hilbert space of a single cell. Our Hamiltonian has the form

(18)

where acts on two cells, i.e., on . Each cell consists of a data and a program cell, i.e., we have

where and denote the Hilbert space of the program and data cell, respectively. We refer to the set of all program cells (i.e., ) as the program band and to that of all data cells (i.e., ) as the data band. The program band initially contains the description of the quantum circuit 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 . The data register is a subset of the data band that corresponds to the register on which acts, i.e., it represents the logical qubits. The remaining part of the data band will only contain formatting symbols.

The Hilbert spaces of the data and program cells are denoted by and , respectively. The basis vectors of are identified with the symbols in

those of of with the symbols in

The program code is composed of the gate symbols , , , , and . These symbols correspond to the identity, , , , and , respectively. The marked gate symbols , , , , and are used to control the propagation of the program code. The symbols , , , and are also used for this purpose. We refer to these symbols as the hole, execution, turn-around, and blank symbols, respectively. The kets and correspond to the two orthogonal states of a qubit. The symbols and are used for 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 in eq. (18) must implement the propagation and the execution of the gates whenever the program is aligned with the data band.

The operator in eq. (18) is thus the product

where applies gates on conditioned on the state of and realizes transitions between basis states of .

Before we define and 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.

\xymatrix

@*[o] @*=¡0em¿@C=1em @R=.7em *!R!¡.5em,0em¿=¡0em¿—x⟩ & *+¡1em,.9em¿W \ar@- [0,-1]\POS[0,0].[1,0];p !C *W,p \save+LU;+RU **\dir-\restore\save+RU;+RD **\dir-\restore\save+RD;+LD **\dir-\restore\save+LD;+LU **\dir-\restore & *+¡1em,.9em¿S \ar@- [0,-1]\POS[0,0].[1,0];p !C *S,p \save+LU;+RU **\dir-\restore\save+RU;+RD **\dir-\restore\save+RD;+LD **\dir-\restore\save+LD;+LU **\dir-\restore & \ar@- [0,-1]& \ar@- [0,-1]& \ar@- [0,-1]
*!R!¡.5em,0em¿=¡0em¿—0⟩ & *+¡1em,.9em¿W \ar@- [0,-1]& *+¡1em,.9em¿S \ar@- [0,-1]& *\xy*+¡.6em¿R;p\save+LU;+RU **\dir-\restore\save+RU;+RD **\dir-\restore\save+RD;+LD **\dir-\restore\POS+LD;+LU **\dir-\endxy \ar@- [0,-1]& *\xy*+¡.6em¿E;p\save+LU;+RU **\dir-\restore\save+RU;+RD **\dir-\restore\save+RD;+LD **\dir-\restore\POS+LD;+LU **\dir-\endxy \ar@- [0,-1]& \ar@- [0,-1]

Figure 1: Example of a simple quantum circuit that acts on qubits and consists of time steps. The first qubit takes the input is . The second qubit is an ancilla qubit.
  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 , where the gaps are used to indicate the different time steps of the quantum circuit . All other program cells contain the blank symbol . Note that the two qubit gates and are encoded by symbol pairs and , respectively, and that the program contains an extra symbol between the blocks (i.e., the layers of the circuit) and the first command of the program reads . In the initial state, the first layer of the circuit is aligned with the data register that is initialized in the state . The symbols to the left and right of the data register enclose exactly two symbols, corresponding to the number of qubits of .

    Figure 2: Initialization of the program and data bands
  2. It is important that the program code starts with the pair . One may rather expect the initial configuration , but this would lead to an execution of in the first step. This is analogous to Section 4, where we have to start in the clock state instead of to prevent the execution of the first annihilation gate . The purpose of this choice of the initial state is to ensure that it is annihilated by the operator 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 on its right side swap their positions. More precisely, if is in the th program cell and in the th cell, then moves to the th cell and to the th cell. While swapping the symbols, the gate corresponding to is executed. It is applied to data cells and if it is a two qubit gate and to data cell if it is a single qubit gate. This only happens only if the data cell and data are inside the data register in the case of a two qubit gate. Similarly, it only happens if the data cell 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 ) 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 into a marked version cell by cell. Once the marked gate symbol is at the begin of the program code it is converted into the hole symbol symbol via the creation of the turn-around symbol .

  4. 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 (via the creation of the intermediate turn-around symbol ). 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 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 ).

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 , , 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 (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 , respectively. The execution symbol is created only if the turn-around symbol 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 . It is the annihilation-creation operator on 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 the operator that realizes the controlled execution of the gates. It is defined by

where

The projectors for act on . and act as identity on and , respectively. and act as and , respectively, on the subspace of spanned by . Similarly, and act as and , respectively, on the subspace of spanned by .

5.2 Spectral properties

We denote the initial state of the QCA by where is the initial state of the quantum circuit to be simulated and 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 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 . 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 have steps instead of until the state is completely annihilated. Likewise, the readout gate causes a conditional annihilation in the step instead of .

To make sure that and the initial state satisfy the conditions of Lemma 1 we have to check that the application of to one of the states in the orbit with indeed leads to the preceding clock state and to an annihilation for . 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 gate. To see that 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 always contains exactly one element in the set . 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 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 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 only appears in rules and 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 and . Again, there is no configuration where both rules can be applied backwards at the same time.

Hence we have shown that meets the requirements of Lemma 1 and that the spectral measure induced by on the initial state depends on the acceptance probability . 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 that and are relatively prime, ensuring that the minimal distance between the supports of the spectra satisfies eq. (15).

6 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.

Acknowledgment

P.W. acknowledges the support by NSF grant CCF-0726771. S.Z. is supported by NSF grant PHY-0456720 and ARO grant W911NF-05-1-0294. We would like to thank Daniel Nagaj for very helpful discussions about the transition rules of the quantum cellular automaton.

Footnotes

  1. Note that the computational power of measurements of “sparse” observables provided the underlying idea for the BQP-hardness proof of diagonal entry estimation problem in [16]
  2. Here a -local operator is defined as an operator that can be written as a sum of terms that act on (not necessarily adjacent) qubits only.
  3. By “uniform circuit” we mean that there exists a polynomial time classical algorithm that generates a sequence of a polynomial number of quantum gates for every desired input length.

References

  1. D. Aharonov, D. Gottesman, and J. Kempe, The power of quantum systems on a line, arXiv:quant-ph/0705.4077, 2007.
  2. D. Aharonov and A. Ta-Shma. Adiabatic quantum state generation and statistical zero knowledge. In Proc. 35th Annual ACM Symp. on Theory of Computing, pp. 20-–29, 2003.
  3. P. Benioff. The computer as a physical system: A microscopic quantum mechanical model of computers as represented by Turing machines. J. Stat. Phys., 22(5):562–591, 1980.
  4. D. W. Berry, G. Ahokas, R. Cleve, and B. C. Sanders. Efficient quantum algorithms for simulating sparse Hamiltonians. Comm. Math. Phys., 270(2):359–371, 2007.
  5. A. Childs. Quantum information processing in continuous time. PhD thesis, Massachusetts Institute of Technology, 2004.
  6. A. M. Childs, D. W. Leung, and M. A. Nielsen. Unified derivations of measurement-based schemes for quantum computation. Phys. Rev. A, 71:032318, 2005.
  7. A. Childs, D. Leung, and M. Nielsen. Unified derivations of measurement-based schemes for quantum computation. arXiv:quant-ph/0404132, 2004.
  8. D. Cvetkovic. Eigenspaces of graphs. Cambridge University Press, 1997.
  9. E. Davies. Quantum theory of open systems. Academic Press, London, 1976.
  10. D. DiVincenzo. Two-qubit gates are universal for quantum computation. Phys. Rev A, 51:1015–1022, 1995.
  11. R. Feynman. Quantum mechanical computers. Opt. News, 11:11–46, 1985.
  12. O. Goldreich. On promise problems. Technical Report 18, Electr. Colloquium Computational Complexity, 2005.
  13. D. Janzing. Computer Science Approach to Quantum Control. Uni-Verlag Karlsruhe, 2006.
  14. D. Janzing. Spin-1/2 particles moving on a 2D lattice with nearest-neighbor interactions can realize an autonomous quantum computer. Phys. Rev. A, 75:012307, 2007.
  15. D. Janzing and P. Wocjan. Ergodic quantum computing. Quant. Inf. Process., 4(2):129–158, 2005.
  16. D. Janzing and Wocjan P. A simple PromiseBQP matrix problem. Theory of Computing, 3:61–79, 2007.
  17. D. Janzing and P. Wocjan. BQP-complete problems concerning mixing properties of classical random walks on sparse graphs. arXiv:quant-ph/0610235.
  18. D. Janzing and P. Wocjan. A PromiseBQP-complete string rewriting problem. arXiv:quant-ph/0705.1180.
  19. J. M. Jauch. Foundations of quantum mechanics. Addison-Wesley, Reading, Mass., 1968.
  20. J. Kempe and O. Regev. 3-local Hamiltonian is QMA-complete. Quant. Inf. & Comp., 3:258–264, 2003.
  21. J. Kempe, A. Kitaev, and O. Regev. The complexity of the local Hamiltonian problem. Proc. 24th FSTTCS, accepted to SICOMP, 2004.
  22. A. Kitaev, A. Shen, and M. Vyalyi. Classical and Quantum Computation, volume 47. Am. Math. Soc., Providence, Rhode Island, 2002.
  23. N. Margolus. Parallel quantum computation. In W. Zurek, editor, Complexity, Entropy, and the Physics of Information. Addison Wesley Longman, 1990.
  24. D. Shepherd, T. Franz, and R. Werner. A universally programmable quantum cellular automaton. Phys. Rev. Lett., 97:020502, 2006.
  25. R. Raussendorf and H. Briegel. Quantum computing via measurements only. Phys. Rev. Lett., page 5188, 2000.
  26. R. Oliveira and B. Terhal. The complexity of quantum spin systems on a two-dimensional square lattice. arXiv:quant-ph/0504050.
  27. B. Travaglione and G. Milburn. Generation of eigenstates using the phase-estimation algorithm. Phys. Rev. A: 63, 032301, 2001.
  28. K. Vollbrecht and I. Cirac. Quantum simulators, continuous-time automata, and translationally invariant systems. arXiv:quant-ph/0704.3432.
  29. P. Wocjan and S. Zhang. Several natural BQP-complete problems. arXiv:quant-ph/0606179.
  30. P. Wocjan, D. Janzing, Th. Decker, and Th. Beth. Measuring 4-local -qubit observables could probabilistically solve PSPACE. Proceedings of the WISICT conference, Cancun 2004. See also arXiv:quant-ph/0308011.
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
""
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
   
Add comment
Cancel
Loading ...
127986
This is a comment super asjknd jkasnjk adsnkj
Upvote
Downvote
""
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters
Submit
Cancel

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test
Test description