The Complexity of Translationally-Invariant Spin Chains with Low Local Dimension

We prove that estimating the smallest eigenvalue of a translationally-invariant, nearest-neighbour Hamiltonian on a 1D chain of quantum systems is QMAEXP-complete, even for systems of low dimension. This improves on the work by Gottesman and Irani (2009), where this dimension was several orders of magnitude larger, whereas our dimension is comparable to the best-known non-translationally-invariant result by Hallgren et al. (2013). The main novelty of our work is the introduction of a new approach to encoding quantum computation in the ground state of a local Hamiltonian, and for analyzing its ground state energy. While previous constructions directly encoded one of the standard models, we introduce a new Turing-complete model of quantum computation - a quantum ring machine. We then translate the ring machine of a QMAEXP verifier into another new model - a quantum Thue system. This hybrid classical-quantum model is an extension of string rewriting systems and is specifically tailored to encoding quantum computation in a nearest-neighbour Hamiltonian with translationally-invariant interactions. This allows us to shift the proof burden from simplifying the Hamiltonians used to encode a standard computational model, to proving universality of a very simplified model. While previous constructions could accommodate only serial computation, quantum Thue systems allow for non-determinism and concurrency. This requires more sophisticated techniques for analyzing the spectrum of the resulting Hamiltonian: we relate it to the Laplacian of a graph with unitary edge weights. To capture the non-deterministic branching in the computational path, we allow arbitrary graphs, including ones with cycles, which goes beyond path graphs considered in all previous constructions.


Background and Motivation
Hamiltonians are the one-stop shop to describing physical properties of multi-body quantum systems, and are of paramount interest for an array of disciplines ranging from experimental condensed matter physics to theoretical computer science [OT05; KKR06; Aha+09; GI13; BH12; CM13; PM15; CPGW15; WL15]. While computer scientists are interested in the computational power of different models, for physicists it is important to calculate the structure of the low-energy spectrum of quantum systems, in particular to approximate the minimum energy of the system, i.e. the ground state energy.
In quantum mechanics, a Hamiltonian H is typically represented by a Hermitian operator on some Hilbert space. The Hamiltonian is the sum of all kinetic and potential energy operators of a system, and its eigenvalues are the system's allowed energy levels: expressed in the Dirac formalism, H |ψ = E |ψ for an eigenstate |ψ with energy E. Since H is Hermitian, the energy is always a real number.
If the underlying Hilbert space is multipartite, e.g. (C d ) ⊗n , we can introduce a notion of locality to a Hamiltonian H by requiring that H can be written as a sum of so-called k-local Hamiltonians, acting non-trivially only on ≤ k subsystems, and as identity everywhere else.
The decision problem of determining whether such a local Hamiltonian operator has lowest energy-or eigenvalue-below some α or above some β, with β > α, can be thought of as the quantum analogue of the maximum satisfiability problem Max-Sat. Similar to the well-known 3-Sat, this asks for the maximum number of clauses of a Boolean formula in conjunctive normal form that can be satisfied simultaneously. The Local Hamiltonian problem is the problem of maximizing the number of local terms of H which can be simultaneously minimized by some global state |ψ , in the sense that ψ| H |ψ is small. This minimum is equal to the lowest energy of the system.
Formally, we can state the Local Hamiltonian problem as the following promise problem.
Instance. Family of k-local Hamiltonians (H n ) n∈N on a multipartite Hilbert space (C d ) ⊗n , with minimum eigenvalue λ (n) min either smaller than α n or greater than β n , such that β n − α n ≥ 1/p(n) for some fixed polynomial p(n). The k-Local Hamiltonian problem has a track record of long-standing interest (cf. table 1). The foundations were laid with Feynman's paper [Fey86] on encoding quantum circuits into the ground state of a Hamiltonian, which motivated a whole series of interesting and increasingly sophisticated results showing that variants of this problem are QMA-complete. The complextity class QMA can be thought of as a quantum analogue of NP: it is the set of decision problems-problems with a YES or NO answer-whose YES-instances have a polynomially-sized quantum witness as proof of correctness. This witness can be verified in locality local dimension geometry and symmetries Kitaev (1999)  poly-time by a BQP machine, i.e. a poly-time bounded quantum verifier. Similarly, QMA EXP corresponds to a quantum analogue of NEXP. We define these complexity classes rigorously in section 2.2, and explain their difference in detail in section 2.4. Hamiltonian constructions in the spirit of [Fey86] are a proof-of-concept and may not necessarily be natural, in the sense that we would not encounter them describing an actual physical system. There are three fundamental criteria for judging the "physicality" of a Hamiltonian: the interactions should be geometrically local, the dimension of the interacting subsystems should be small, and the interactions should exhibit translational invariance. These properties apply to physical systems we typically encounter in nature. For example, translational invariance means that if the Hamiltonian is specified on a lattice, the interactions are the same independent of the location within the lattice.

Question. Is λ
Starting with Kitaev's original proof of QMA-completeness of 5-local Hamiltonian [KSV02a], the locality and local dimension of the constructions were improved successively [KKR06; OT05;Aha+09]. For 2-Local Hamiltonian with interactions between neighbouring spins on a chain, QMA-hardness with local dimension 8 was proven by Hallgren et al. [HNN13]. All of these results make heavy use of non-translationally-invariant interactions as they vastly simplify the encoding of the problem instance and verifier circuit into the local structure of the Hamiltonian.
The QMA EXP -hardness result 1 by Gottesman and Irani [GI13], which features a geometrically 2-local Hamiltonian on a line with translationally-invariant interactions, shows that having translational symmetry does not change the complexity class of the local Hamiltonian 1 QMA EXP is similar to QMA, but with an exponential-time verifier instead of polynomial-time. This is a necessary technicality due to the input effectively being specified in unary. The energy gap still scales inverse-polynomially with chain length, and the physical implications are exactly the same as for QMA-completeness.
problem. But one caveat remains: there, the local dimension is unphysically huge, on the order of 10 6 .

Main Results.
In this work, we develop a set of new methods to drastically reduce this local dimension-down to 42-and show the following main result. Whereas recent results [PM15] make use of perturbation gadgets-approximating higherorder interactions in the low-energy subspace of the system by an effective high-energy theory-it is known that this does not work in one-dimensional systems [Aha+09]. The improvements in [HNN13] over [Aha+09] are possible however by approximating 4-local interactions by a sum of 2-local interactions, effectively introducing illegal transitions that have to be penalized. Both perturbation gadgets and the locality reduction depend on introducing a large energy scale to project out illegal subspaces. Our results, on the other hand, do not use perturbation theory 2 .
Furthermore, previous constructions are all based on encoding one of the standard models of quantum computation-almost always the circuit model, with the exception of [GI13] which encodes a quantum Turing machine, neither of which are optimized for this task.
Our findings are based on the following three main stepping stones: 1. We first define a new universal computational model-a quantum ring machine (QRM)which is computationally equivalent to a uniform family of quantum circuits.
2. We next introduce unitary labeled graphs and their associated Hamiltonians, which can accommodate computation with multiple branches executed in parallel. This vastly generalizes Feynman's original clock construction [Fey86], which corresponds to a path graph in our setup. Mirroring Kitaev's analysis [KSV02a], our Hamiltonian is also equivalent to a Laplacian of the corresponding graph. Together these tools allow us to analyse ground states of much more complicated Hamiltonians than previously possible.
3. We define yet another computational model-a quantum Thue system, or a quantum string rewriting system-that is particularly well-suited for embedding computation into local interactions, and can be thought of as an assembly language for programming local Hamiltonians.
We finally combine all three toolsets and explicitly construct a family of QMA EXP -hard instances of 2-Local Hamiltonian. Classical wires encode where the next quantum gate from a small universal set will be applied.

Proof Ideas.
A Simpler Computational Model. We first simplify the computational model we want to utilize for our construction. The complexity class QMA EXP is usually defined in terms of the circuit model, i.e. as a uniform family of verifier circuits: a promise problem L = (L YES , L NO ) is in QMA EXP if there exists a classical Turing machine, such that the verifier circuit for a problem instance l ∈ L can be written out by the Turing machine in O(exp |l|) steps where |l| is the instance size. Being used as an all-purpose computational model, Turing machines have significant downsides: they have complicated transition functions, need a lot of internal states (which translates to an enormous local dimension when encoded in a Hamiltonian) and are rarely written out explicitly. On the other hand, in past constructions, embedding a circuit directly required the use of non-local clock states marking the position within the circuit, or non-translationally-invariant terms that encode the circuit unambiguously. We introduce a new computational model which allows us to circumvent the direct use of complicated Turing machines or quantum circuits. The so-called quantum ring machine consists of a cyclic ring and a head unitary S. At each step, this head moves in the same direction along a ring of qubits and cyclically acts on adjacent cells. We give the following formal definition.
Definition 3 (Quantum ring machine). A quantum ring machine is a tuple (S, n), where S is a unitary operator on a pair of qudits (C d ) ⊗2 , and n ∈ N. Denote with (C d ) ⊗n a ring of n qudits. S is applied cyclically to two adjacent sites of this ring-see figure 2-until one of the ring sites is in a specific halting configuration |q f ∈ C d .
To show that a quantum ring machine is computationally equivalent to a uniform family of quantum circuits, we encode a classical Turing machine's transition function into S, where the internal states, including the Turing machine's halting flag, are stored as a classical information on the ring. Such ring machine can be used to write out and execute a quantum circuit "on-the-go": it is universal for whichever uniform circuit class is encompassed by its allowed runtime. Quantum ring machines thus bridge the gap between circuits, which are particularly simple to specify locally but have a complex global structure, and Turing machines, which are difficult to specify locally due to a possibly large number of internal states, but have a straightforward global evolution as the tape only changes in at most one location at each step. A schematic of the ring machine can be found in figs. 1 and 2.
The ring machine's simple mechanism allows its evolution to be described by a set of local quantum rewriting rules. These rules operate at a physical level while the ring machine operates at a logical level-each application of ring machine's head S on a pair of logical qubits is implemented by a sequence of physical operations acting on a much larger number of qubits. At any given time the ring machine's head is positioned on a specific pair of logical qubits, and after each application of S this location is updated in a similar fashion as Turing machine's head-it is shifted either up or down along the ring by one position. Overall, S is a large controlled unitary that acts at a given logical location only if the ring machine's internal state-stored as a classical bit on the physical tape-is in an active configuration.
Treating the Hilbert space of the 2-Local Hamiltonian problem as a physical tape of length n-some symbols quantum, some classical-we write a set of transition rules to perform the following steps that simulate the quantum ring machine.
1. As in the construction by Gottesman and Irani [GI13], we use a counter to translate the chain length n into a program string of length O(log n) on the left hand side of the tape while on the right hand side we store the physical data qubits.
2. This program contains a physical-level description of a quantum circuit (over a universal gate set) for approximately implementing one step of the quantum ring machine, i.e. one application of the ring machine's head S. The program's rightmost bit always indicates the next gate in the circuit, and this gate is always applied to the two leftmost data qubits on the physical tape (see fig. 3).
3. Using the two types of commands shown in fig. 3, the circuit implementing S can be executed cyclically on the physical data qubits, some of which are initialized to ancillary |0 's to be used in the computation.
4. The computation runs until a certain internal classical counter terminates. The length of the chain is chosen so that the program encodes a quantum ring machine equivalent to a BQEXP verifier circuit. It discriminates between YES and NO instances of the corresponding QMA EXP language depending on whether the ring machine accepts or rejects, and a special symbol in the program description allows us to locally penalize a wrong initialization of ancillas and a NO output of the computation.
Our construction is universal in the sense that it can be used to implement an arbitrary quantum computation without the need to increase the local dimension (in the same spirit as a universal Turing machine can implement any computation without the need to increase the number of internal states). We make heavy use of branching to reduce the local dimension of the underlying spin chain, which makes it necessary to develop a new set of tools to prove soundness and completeness of 2-Local Hamiltonian for QMA EXP . Figure 3: Illustration of Turing's wheelbarrow construction (see section 7 for more details). It consists of a tape that stores a program string on the left-and data qubits on the right-hand side. Two types of actions are supported: application of a quantum gate (left figure) and rewinding of the tape (right figure). The rightmost program bit always indicates the next action. For example, 0 indicates that a unitary gate U 0 should be applied to the two leftmost data qubits, and the ring of qubits should then be cyclically rotated one position to the left. On the right, the action of the special symbol is depicted: it signals the rightmost qubit to move back to the left end of the tape. After each action the program string is cyclically rotated one position to the right.

Spectral Analysis for Hamiltonians Encoding Non-Deterministic Computation.
We represent the spin chain of length n as the Hilbert space H ⊗n . The interactions on this chain then take the form of a set of local rewriting rules acting on neighbouring pairs of spins: for |ψ i , |φ i ∈ H ⊗2 we encode the evolution |ψ i → |φ i by a local Hamiltonian The overall Hamiltonian is then a sum of these local interactions over all sites, i.e.
If all |ψ i and |φ i are standard basis vectors, then each rule corresponds to an edge in a graph G with vertices labeled by the canonical basis of the spin chain. H thus equals the Laplacian of the graph G and the ground state of H is given by the uniform superposition over connected graph components of G. We call ground states of such Hamiltonians based on transition rules, history states.
To analyse the spectrum of more general non-basis transitions |ψ i → |φ i , one needs to prove that this choice still allows H to be at least unitarily equivalent to a graph Laplacian ∆, e.g. by explicitly constructing a global unitary W such that W † HW = ∆ ⊗ 1. Past work only allowed a very limited set of local terms to occur in H, in particular limiting the structure of ∆'s ground and first excited states' connected graph components to path graphs (!), at most with single-vertex branches [HNN13]. In the language of rewriting rules, this means that almost every rewriting rule has to be uniquely applicable to the current computational step, i.e. the model used to embed a verifier computation is limited to local, deterministic, Turing machine-like head movements.
A more complex construction with a local clock was considered in [BT13], where the authors allowed transition rules in parallel on a two-dimensional surface, as long as the execution front behaved in a time-like fashion. In order to analyze the spectrum of the resulting Hamiltonian, the propagation terms were related to the diffusion of a string on a torus, corresponding to a ferromagnetic Heisenberg model with partially twisted periodic boundary conditions. The analysis, while elegant, is relatively specific, and this form of concurrency e.g. does not allow true branching or loops in the program execution. We extend this notion to allow much more complicated branching in the computational path to occur. In particular, we prove a series of results which guarantee the existence of the unitary W mentioned above solely based on properties of the local interactions, without the need to explicitly analyze the overall evolution of the system. This has two major benefits: it allows more powerful rewriting rules which are not necessarily unique for every step, and it drastically simplifies the spectral analysis of whichever construction we choose to work with, as we do not need to construct the equivalence between H and ∆ explicitly.
In a bottom-up approach, we formalize the notion of a Hamiltonian associated with a graph. Starting from a simple directed graph G = (V, E) we associate a Hilbert space H to each vertex v ∈ V, and a unitary U (a,b) : H −→ H for every directed edge (a, b) ∈ E, and call graph with Hilbert space and family of unitaries a unitary labeled graph, or ULG for short. As an example, consider fig. 4.
The associated Hamiltonian for the ULG is then defined as where the |i label a basis of H. Observe that this construction is more general than a local Hamiltonian on a spin chain, and H(G) is simply regarded as Hermitian operator on the overall Hilbert space C V ⊗ H: the vertex labels are completely arbitrary, and not necessarily strings from an alphabet. The associated Hamiltonian H(G) bears some structural resemblance with a graph Laplacian, as already mentioned. We prove the following theorem.  We provide an explicit expression for this diagonalizing unitary. What remains to be shown is whether the transition rules that we specify for the execution of our ring machine exhibit this property of simplicity. The spectral analysis of the resulting Hamiltonian can be performed using a version of Kitaev's geometrical lemma.
To formalize the notion of string rewriting rules and to reintroduce locality to our Hamiltonian construction, we further develop a notation which significantly facilitates embedding these transitions into the ground state of a local Hamiltonian.
Quantum String Rewriting. Past hardness constructions (summarized in table 1) encode computation in local transition rules that act on spins connected by some underlying graph of interactions. While some of these transitions are classical-i.e. basis-preserving-others act on the spin states with a non-diagonal unitary operator, performing the actual quantum computation. Inspired by classical string rewriting systems, we interpret these quantum interactions as local quantum rewriting rules, and introduce a new abstract rewriting system called quantum Thue system. This extends an already-existing model of string rewriting-semi-Thue system, named after the Norwegian mathematician Axel Thue-which are well-studied classically [Tho10].
Such a classical Thue system consists of a finite alphabet Σ and length-preserving replacement rules for strings over this alphabet. Similar to the word problem, computation can be encoded in the question whether there exists a connecting path between some input and output strings s i and s f . It is straightforward to simulate universal classical Turing machines with a Thue system, which shows that the latter is a Turing-complete model for classical computation. But what about quantum computation?
For quantum Thue systems, we require that the alphabet splits into a classical and a quantum part, i.e. Σ = Σ cl Σ q . Transition rules can be purely classical-between elements of Σ * cl , quantum-between elements of Σ * q , or a mixture thereof, in which case we require that the rule preserves the number of quantum symbols |s| q of a string s ∈ Σ * . In addition, every rule r acting on at least some quantum symbols has a unitary U r ∈ B(H ⊗|s| q ) attached, where H is some fixed, finite-dimensional Hilbert space.
Starting on some string s and a vector |v ∈ H ⊗|s| q , we apply any matching string rewriting rule s r −→ s in turn. For every replacement, we also apply the corresponding unitary to the vector, i.e. U r |v = |v . In this fashion, we can model quantum computation, driven by a finite automata: if we make the underlying classical Thue system implement a Turing machine that writes out a quantum circuit description on the string, and then perform this quantum circuit on a separate set of qubits attached to some quantum symbols.
One can then show that a quantum Thue system is itself a special case of a unitary labeled graph, which allows us to translate it into a Hamiltonian. We show that the locality of the resulting Hamiltonian only depends on the range of the largest replacement rule, e.g. if one at most replaces a 3-character string, the resulting Hamiltonian will also be 3-local and translationally-invariant.
As replacement rules are not necessarily unique, the computation will have potential ambiguities. As such, we regard all strings connected to the initial starting string s i via some arbitrary combination of rules, and the size of this set corresponds to the number of basis states that the so-called history state-i.e. the ground state of the Hamiltonian that we want to embed the computation in-is comprised of.
With all this machinery, we can write a quantum Thue system which executes a quantum ring machine, which in turn allows us to prove the following lemma.
Lemma 5. There exists a BQEXP-universal quantum Thue system with 39 symbols, 3 of which are quantum, with attached Hilbert space C 2 and 2-local rules.
For this QTS-which we construct explicitly, and which makes heavy use of the new possibilities of branching and concurrency-we prove a series of further properties that allow us to single out the history state for any YES-instance. Furthermore, we prove that the QTS has a simple history state in the sense of theorem 4, which allows us to analyze the spectrum of the resulting Hamiltonian and prove our main result, theorem 2, that 2-Local-Hamiltonian is QMA EXP -hard.  where we used the convention that the head sits on the tape and reads/writes the symbol to its right. The resulting Hamiltonian will be 3-local, and its ground space will consist of superpositions of states representing a valid evolution of the Turing machine.
It is straightforward to rephrase several of the former results in this notation, and translate them into a local Hamiltonian. If the rules do not allow branching, the associated ULG will automatically be simple; for more complicated constructions such as [BT13], one has to verify that the concurrent paths converge to the same outcome. In their case, this is obvious, as non-commuting gates are never executed out of order. It usually suffices to show that the graph corresponding to valid history states is simple, as all invalid ones can be readily penalized and thus pushed away from the ground state, cf. theorem 61.

Structure of the Paper
We begin by summarizing several standard definitions in section 2. In section 3, we define the aforementioned quantum ring machine and show that it is indeed Turing complete for quantum computation. Section 5 formalizes the notion of quantum replacement rules and introduces the model of quantum Thue systems. Section 7 contains the constructive proof of a universal quantum Thue system, and section 6 combines everything into our main hardness result.

Reversible Turing Machines
We give the following standard definition of a (non-deterministic) Turing machine (for more background on Turing machines, see Chapter 8 of [HU79]).
Definition 6 (Turing machine). A Turing machine-or TM for short-is a triple (Q, Σ, δ), where Q is a finite set of internal states containing a distinct initial and halting state q 0 and q f , respectively, and Σ is a finite set of tape symbols containing a designated blank symbol 0. Each element of the transition set δ is a quintuple of the form (q, s, s , d, q ), which means that if the Turing machine reads a symbol s under its head while in state q, it overwrites the symbol by s , moves the head in direction d ∈ {left, right} and transitions to state q . At the beginning of the computation, TM's initial state is q 0 and the tape is initialized to all 0s except for a finite block of consecutive cells containing the input. The machine halts once its internal state is q f , for which there is no forward transition.
As we aim to implement TMs using quantum mechanics, we need them to be deterministic and reversible. The following is based on Definition 10 from [Mor08].
Definition 7 (Deterministic and reversible Turing machine). Consider a Turing machine (Q, Σ, δ), and let (q 1 , s 1 , s 1 , d 1 , q 1 ) and (q 2 , s 2 , s 2 , d 2 , q 2 ) be any two distinct quintuples in δ. This TM is For a deterministic TM, one can regard δ as a partial function, namely δ : Q×Σ → Σ×D×Q where D := {left, right}, since all combinations of internal state q and tape symbol s have at most one forward transition. For a reversible TM, δ is injective since all combinations of internal state q and tape symbol s have at most one backwards transition (whenever such transition exists, it uniquely determines the head movement direction d backwards). In fact, according to definition 7, each state of a reversible TM can be entered only from one direction (this property is referred to as unidirectionality in [BV97]). In other words, it is sufficient to know only the TM's current state (as opposed to both the state and the tape symbol) to answer the question "From which direction did the TM's head arrive?".
Due to unidirectionality, it is often natural to restrict the range of δ to Q × Σ. In fact, the transition function δ of a deterministic reversible Turing machine can be replaced by a permutation matrix on Q × Σ without affecting the TM's behaviour. For our convenience, we state this observation more formally (see also cor. B.2 and thm. 4.2 in [BV97]).
Lemma 8. The partial transition function δ of any deterministic reversible Turing machine (Q, Σ, δ) can be replaced by a pair (T δ , d), where T δ is a permutation matrix on Q × Σ and d : Q → D is a function that determines, for each internal state q ∈ Q, the direction from which the TM's head arrived in q. If we update the TM's internal state and the current tape symbol according to T δ , and then move the TM's head in the direction opposite to d(q ) (where q is the updated state), the behaviour is identical to the original transition function δ.
Proof. The function d is readily obtained because of unidirectionality. A blueprint of T δ is obtained by restricting the range of δ to Q × Σ and describing δ's action on the elements of this set by a binary matrix. Since the TM is deterministic and reversible, this matrix contains at most one entry 1 in each row and column, so it can be easily extended to a permutation matrix.
From now on we will consider only deterministic Turing machines and implicitly assume that they are reversible-this is justified by the following result due to Bennett [Ben73] (see [Per13;Mor08] for more background on reversible computation).
Theorem 9 (Bennett [Ben73]). Any deterministic TM can be made reversible with at most polynomial overhead in terms of space and time.

Quantum Complexity Classes
We begin by formally defining the quantum complexity classes BQP, BQEXP, QMA and QMA EXP in terms of the circuit model, and refer reader to [BV97; Wat12; VW16] for more details on quantum computational complexity.
In what follows, we fix some finite universal set of 2-qubit quantum gates, such as {Hadamard, Cnot, R(π/4)}-see [NC10,ch. 4.5]. We begin by defining a uniform family of quantum circuits over this gate set.
Definition 10 (Uniform family of quantum circuits). Let f : N → N be a function and (C n ) n∈N be a family of quantum circuits where each C n • acts on n qubits and has a distinct output qubit, • requires at most f (n) additional ancilla qubits initialized in |0 , • contains at most f (n) gates from our universal set.
We say that (C n ) n∈N is f (n)-uniform if there exists a TM that on input 1 n produces an explicit description of C n in less than f (n) steps.
Let Σ be a finite set (alphabet), and let Σ n and Σ * := n≥0 Σ n denote the sets of all length-n and all finite-length strings over Σ, respectively. A promise problem over alphabet Σ is a pair L = (L YES , L NO ) such that L YES ∩ L NO = ∅, where L YES , L NO ⊆ Σ * are the sets of input strings corresponding to YES and NO instances, respectively. We will sometimes write l ∈ L meaning that l ∈ L YES ∪ L NO .
where C n (s) denotes the random variable obtained by executing C n on input s ∈ L of size n = |s| and measuring the output qubit (the encoding of s as well as the measurement are performed in the computational basis).
We chose to introduce the notation BQ(f ) on purpose, to emphasize the fact that the definitions of classes BQP and BQEXP are essentially the same up to the bounding function: It is a well-established fact (see [Wat12,Prop. 3]) that for BQP the error probabilities of 2/3 and 1/3 in definition 11 can be exponentially amplified (the same argument works for BQEXP as well, since we only need a polynomial number of repetitions).
Fact 12 (Error-reduction for BQP and BQEXP). For any polynomial p, we can assume that Pr(C n (s) = YES) ≥ 1 − 2 −p(n) for s ∈ L YES and Pr(C n (s) = YES) ≤ 2 −p(n) for s ∈ L NO in the definitions of BQP and BQEXP.
Intuitively, QMA(f ) is the class of promise problems for which the YES/NO answers can be verified by a BQ(f ) verifier.
there exists an f (n)-uniform family of verifier quantum circuits (C n ) n∈N (with n input qubits for the instance description and f (n) input qubits for the witness) such that probability at least 2/3. This condition is known as completeness.
• if s ∈ L NO , ∀ witness states ρ on at most f (n) qubits C n (s, ρ) = YES with probability at most 1/3. This condition is called soundness.
Observe that the witness size is implicitly constrained by the size of the quantum circuit family, cf. definition 10, e.g. for BQP verifiers the witness is poly-sized while for BQEXP verifiers it can be exp-sized. As before, we define QMA := k∈N QMA(n k ) and QMA EXP := k∈N QMA(exp(n k )).
Note that Fact 12 can be used to amplify error probabilities for QMA and QMA EXP as well.

Geometrically k-Local Hamiltonian
In this section we introduce basic notions relating to local Hamiltonians and formally state the (k, d)-Hamiltonian problem that will play central role. For more background on Hamiltonian complexity, see [Gha+14; KSV02b; Wat12].

Definition 14. An n-qudit Hamiltonian is a Hermitian operator H acting on a multipartite
Hilbert space (C d ) ⊗n consisting of n systems (qudits), each of local dimension d.
We will label the individual systems by elements of S := {1, . . . , n}. Whenever we talk of a subset of systems A ⊆ S, we mean an ordered tuple of distinct elements of S. If h is a k-qudit Hamiltonian for some k ≤ n and A ⊆ S is a subset of |A| = k systems, we write h A to denote the n-qudit Hamiltonian that acts as h on qudits A and trivially (i.e. as 1) on the remaining qudits S \ A. We also write A + i ⊆ S to denote A shifted by i ∈ N positions.

Definition 15. Let H be an n-qudit Hamiltonian. Then
Our central problem of interest is deciding the ground energy of a 1D translationallyinvariant k-local Hamiltonians of local dimension d. For brevity, we will refer to this as the (k, d)-Hamiltonian problem.

Input. The chain length n and the matrix entries of h, up to O(poly n) bits of precision.
Promise. The operator norm of each local term is bounded, h ≤ poly n, and either λ min (H) ≤ α n or λ min (H) ≥ β n , where λ min (H) denotes the smallest eigenvalue of H and β n − α n ≤ 1/p(n) for some polynomial p(n).
We emphasize that the input in definition 16 is just the description of the k-local term h and the chain length n, not the entire (exponentially-sized) Hamiltonian H. An equivalent variant of the definition requires the norm h ≤ 1 and gives a promise that either λ min (H) ≤ α or λ min (H) ≥ β for some fixed constants β > α. We can always rescale the overall Hamiltonian by a polynomial factor to switch between the two definitions.
Proof. The claim follows from a random sampling argument as given for QMA in [KSV02b].

QMA versus QMA EXP
We want to make clear the distinction between the two classes QMA EXP and QMA for the local Hamiltonian problem, which arises because of the 1/ poly promise gap in the problem description. In particular, we want to clarify what additional restrictions on the local Hamiltonian terms arise when proving completeness for one or the other.
There are two parameters for the local Hamiltonian problem on a line that can be used to specify an input, i.e. a problem instance. The first one is by varying the local Hamiltonian terms. The second possible input is the system size N , e.g. the chain length; but since this is a unary specification of a natural number, the information content of this input is O(log N ). As a simple example, assume that the Hamiltonian H is specified by a single local term, Then the bit complexity of this input is O(m + log N ), and the overall input size-i.e. the possible information specifiable using the two parameters N and m is thus as well bounded by O(m + log N ). A fact which we will discuss in great detail in section 5 is that the gap of a Hamiltonian encoding computation as a superposition of basis states-a so-called history state construction-scales inversely polynomially in the runtime, i.e. 1/ poly(f (l)) for an input of size l and an f (l)-time computation. Contrasting this with the 1/ poly N gap required by definition 16-inverse polynomially in the system size-we conclude the following core differences between QMA and QMA EXP .
QMA. Only specifying the chain length N yields an input of size l = O(log N ), a runtime of l = poly log N , and therefore a gap scaling as O(1/ poly(poly(log N ))) = O(1/ poly(log N )). This satisfies definition 16, but leaves room for more input: we can add an extra input of size m = O(poly N ) to one or more of the local terms without making the gap close too quickly.
QMA EXP . If we only specify the chain length as input and keep the local terms fixed, the input for a chain length N is of size l = O(log N ). The gap thus scales as O(1/ poly(exp(log N ))) = O(1/ poly N ), as required for definition 16. If instead we also were to use the local terms to specify an extra input of size Ω(poly(log N )), the gap would close too quickly, violating definition 16.
Remark 18. It is thus natural to allow O(poly N ) precision of the entries in the local terms of the Hamiltonian when working with QMA, whereas for QMA EXP local terms need to be precision-limited by O(poly log N ). However, we will only make use of uniformly scaling local interaction terms, as in [GI13]: this in particular allows us to use coupling constants that scale polynomially in N .
In [CPGW15], the authors use a phase-estimation algorithm to extract O(N ) bits of information from a fixed Hamiltonian term. However, in their construction, the speed at which the gap closes was irrelevant, as long as it remains nonzero in the gapped phase.
With It is clear that this is a problem of bootstrapping. We only have O(log N ) information available to start the computation with, and it is not known whether there exists a more direct way of extracting a phase without having to go through Solovay-Kitaev, which only gives a sufficient upper bound to approximate the phase estimation algorithm.

Laplacian Matrix and Algebraic Connectivity of Graphs
In this section we revise general notation and basic results from graph theory. For more background, consult the standard references [Tru13; Die10] and [GR01] on graph theory and algebraic graph theory, respectively.
We will usually omit the qualifiers "undirected" and "simple" in the rest of this paper. We proceed by introducing basic notions and facts from algebraic graph theory [GR13].

Definition 20 (Laplacian matrix). The Laplacian matrix of a graph G is defined as ∆(G) := D(G) − A(G).
Since A(G) and ∆(G) are linear operators on C V , it will often be convenient to label the basis vectors of this space by |v where v ∈ V. Proof. By construction, A(G) and D(G) are real symmetric and so is ∆(G). The second claim follows by observing that ∆(G) is symmetric and diagonally dominant. Alternatively, ∆(G) can be expressed as a sum of positive semidefinite matrices: where each term is a principal submatrix of the form which encodes the Laplacian of a single edge. The last statement follows from the fact that the row sums of ∆(G) are zero.
Definition 23 (Algebraic connectivity). The second smallest eigenvalue of the Laplacian ∆(G) is denoted with a(G) and called the algebraic connectivity of graph G. The corresponding eigenvector is known as the Fiedler vector.
Claim 24 (Fiedler [Fie73]). For any graph G, a(G) > 0 if and only if G is connected.
Lemma 25. If G = G 1 · · · G m is a disjoint union of connected components G i then ∆(G) has eigenvalue 0 with multiplicity exactly m and the next smallest eigenvalue is Proof. Note that ∆ = ∆ 1 ⊕ · · · ⊕ ∆ m where ∆ i is the Laplacian of G i . Recall from Claim 22 that ∆ i ≥ 0 and λ min (∆ i ) = 0, hence the m smallest eigenvalues of ∆ are equal to 0. Since each G i is connected, a(G i ) > 0 for every i by Claim 24. Hence the multiplicity of eigenvalue 0 must be m and the (m + 1)-st smallest eigenvalue of ∆ is positive and equal to a(G i ) for some i. Finally, recall from Claim 22 that the uniform superposition over all vertices V i of G i is a 0-eigenvector of ∆ i , thus ∆ |Ψ i = 0 for each i ∈ {1, . . . , m}. There are no further vectors in the ground space of ∆ since ∆ has eigenvalue 0 with multiplicity m.
In fact, any 0eigenvector of ∆ is a superposition of such vectors.
Proof. The algebraic connectivity is non-decreasing under adding edges [Fie73, corollary 3.2], so for any connected graph on L vertices it is lower-bounded by that of a path graph on L vertices, which is given by Claim 27.

Kitaev's Geometrical Lemma for Graphs
We will need Kitaev's geometrical lemma (see Lemma 14.4 in [KSV02b]) whose proof is reproduced below. Proof. We define Π A to be the projector onto ker A, and analogously for Π B . It follows from In other words, we want to show that if λ is an eigenvalue of Π A + Π B then 1 + cos θ ≥ λ . (2) Let |ψ be a normalized eigenvector of Π A + Π B with eigenvalue λ ≥ 0. Since eq. (2) holds trivially for λ = 0, we can assume λ > 0. Since Π A projects onto ker A, we can find a unit vector |ψ A ∈ ker A such that Π A |ψ = a |ψ A for some a ∈ C; we can adjust the global phase of |ψ A to guarantee that a ≥ 0. Similarly, Π B |ψ = b |ψ B for some unit vector |ψ B ∈ ker B and b ≥ 0. Since Π A and Π B are projectors, ψ| Π A |ψ = ψ| Π † A Π A |ψ = a 2 ψ A |ψ A = a 2 and ψ| Π B |ψ = b 2 . Since |ψ is normalized, from λ |ψ = (Π A + Π B ) |ψ we get Furthermore, and hence λ ≤ 1 + cos θ, which proves eq. (2).
We want to use Kitaev's geometrical lemma to lower bound the smallest eigenvalue of a graph Laplacian if we give a penalty to certain vertices. To be more specific, for a graph G = (V, E) and a set of vertices P V, we write a penalizing matrix P(G, P) := v∈P |v v| .

The Quantum Ring Machine as a Universal Model
We define a new computational model and show that it is poly-time equivalent to a uniform family of quantum circuits, where the uniformity condition is inherited from the corresponding class of Turing machines, e.g. poly-time or exponential-time.
Definition 31. A quantum ring machine-QRM for short-is a tuple (S, n), where S is a unitary operator on a pair of qudits (C d ) ⊗2 , and n ∈ N. Denote with H = (C d ) ⊗n a ring of n qudits. Starting from the ring in an initial configuration |q i ∈ H, S is applied cyclically to two adjacent sites of the ring-see figure 5-until one of the ring sites is completely in a specific halting subspace H f ⊆ C d . Fig. 6 visualizes a QRM with a ring of size 4 as a quantum circuit. Because the ring is cyclic, we can arbitrarily mark a starting position on the ring. Starting at this position, part of the initial state |q i contains the input while the rest is padded by a special symbol and will be used as a workspace. The input size is thus clearly upper bounded by the ring size. Proof. Our goal is to construct a QRM for simulating a classical Turing machine (TM) that produces a description of a uniform quantum circuit (this TM is reversible without loss of generality, see theorem 9). In addition to computing the circuit's description, the QRM • in addition to the classical data, each cell of the TM's tape stores one qubit, • a special subset of the TM's states is associated with a universal set of two-qubit quantum gates; whenever the TM enters one of these states, the corresponding gate is applied on the qubits of the two adjacent cells between which the TM's head has just moved.
It is straightforward to verify that such quantum-enhanced TM is equivalent to a uniform family of quantum circuits. Let us now describe the simulation procedure more formally. We write the complex linear span of a finite set S as C S := span{|s ∈ C |S| : s ∈ S} and refer to (C S ) ⊗n as a ring of size n ∈ N, where each copy of C S represents one cell of the ring. Each cell further consists of three registers: a quantum bit (labelled by {0, 1}), a classical data register (labelled by elements of some finite set Γ), and a flag register (labelled by another set F). The standard basis of each ring cell is thus labelled by triples of the form S := {0, 1} × Γ × F.
Using the notation from definition 7, let (Q, Σ, δ) be the deterministic TM we intend to simulate (it is reversible without loss of generality, see theorem 9). The first register of the QRM stores the quantum state obtained by executing the quantum circuit which is produced by the TM. The second register Γ stores the TM's internal state and tape, so Γ := Q × Σ where Q is the set of internal states and Σ is the TM's alphabet. The flag symbols F in the third register are used to mark the location of the TM's head.
The flag register's alphabet is given by and is used as follows. At any time, exactly one cell on the ring contains an active flag (either "←", "→", or "h") while the rest are padded with "−". The TM's internal state is always stored in the active cell. Unless the TM has halted (indicated by flag "h"), the active flag shows in which direction ("←" for left and "→" for right) the TM's head must be moved before the simulation of the next step can begin. Every time the TM's head moves or its internal state changes, the QRM updates the flag registers and the description of the TM's internal state accordingly. Whenever the TM enters one of the special "quantum" states, the QRM applies the corresponding two-qubit unitary.
Recall from definition 31 that QRM operates by cyclically applying a fixed unitary S on pairs of consecutive cells along the ring (see fig. 6). Most of the time S acts trivially, since a non-trivial action is triggered only when either of the two active flags "←" or "→" is encountered. Note that S acts on two adjacent cells. While only one of them is marked by the active flag, the other cell is indicated by the flag's arrow: It is crucial that S is two-local for the following two reasons. First, updating the active location requires changing two symbols (e.g. when the TM's head moves left, we need to replace "− ←" by "← −" or "→ −", depending on the direction the head will move next).
For applying a two-qubit gate, we clearly also need a two-local interaction (we use the same convention as above to determine on which two qubits the gate is applied).
Recall from lemma 8 that, instead of quintuples δ, we can work with a permutation matrix T δ on Γ and a function d : Q → {left, right} telling us where the TM's head came from. For convenience, we include a special dummy state ⊥ in Q. We accordingly extend T δ so that it acts trivially on |⊥, σ for any σ ∈ Σ, and we define d(⊥) := − so that dummy states do not trigger any action in our simulation.
We take the ring size to be n = p(|x|) for an instance x ∈ L, as the TM can access at most that many tape sites. We require that the ring starts out in a well-formed state, i.e. any state from the subspace where all of the cells are initialized in the dummy state ⊥, TM's tape is initialized to some "blank" symbol σ, and all the flags are −, except for the last cell which contains the initial state q 0 and the → flag. The input x ∈ L is written on the qubit part of the tape.
We can now describe in more detail the steps involved in our simulation, and how to perform them reversibly (see figs. 7 and 8 for more details): 1. If the active cell contains h, the TM has halted, so nothing happens.
2. If the active cell is in one of the other two states "←" or "→": a) The Q part of the Γ registers of the active cell and its neighbor-indicated by the flag-are exchanged, thus simulating the movement of the TM's head.
Classical computation C on internal states and a classical tape Figure 7: Circuit diagram for implementing the QRM's head unitary S (double wires are classical while single wires are quantum). All computation is classical except for a single classically-controlled quantum gate U that can be triggered by either of the two Γ registers. A classical circuit for implementing C is shown in fig. 8.
b) The flag register of the active cell is uncomputed using the function d.
c) Description of the TM's internal state and the current tape symbol is updated using T δ . d) Based on the updated internal state, a new flag register is computed using d (it belongs to the same cell where the TM's new state is stored, and it indicates in which direction the TM's head will move before the next iteration begins). e) If the TM is in one of the special states, the corresponding unitary is applied on the two data registers.
We describe the unitary operator S that acts on two adjacent QRM's cells: • For a = (ψ a , γ a , f a ) ∈ S, write the corresponding basis state as |a := |ψ a , γ a , f a ∈ C S where ψ a ∈ {0, 1}, γ a ∈ Γ, f a ∈ F, and analogously for |b . Then |a ⊗ |b ∈ C S×S is also a basis state and we require, up to reordering the registers (see fig. 7), that for some γ a , γ b ∈ Γ and f a , f b ∈ F, i.e. S acts classically on each register except for the quantum data registers |ψ a and |ψ b -in particular, we allow |Ψ ∈ C 2 ⊗ C 2 to be entangled.  then f b = − and f a = −, meaning that the head has moved left. In each case there are three possible transitions; they indicate whether the TM has halted or in which direction its head has to move next: Fig. 7 shows how S acts on two adjacent cells. The halting subspace for each cell is simply spanned by all standard basis vectors with the last register being in the halting state |h . Fig. 8 provides details on how to implement C reversibly. We construct the desired family of QRMs (M x ) x∈L in the special form described above. It is straightforward to verify that this ring machine executes the circuit written out by the TM, and the runtime overhead of M x as compared to the circuit is at most quadratic.
Replacing polynomials with exponentials, the same proof goes through for BQEXP.
Corollary 34. Let L = (L YES , L NO ) be a promise problem in BQEXP. Then there exists an exponential-time terminating family of QRMs (M s ) s such that for x ∈ L YES , the QRM M |x| transitions to an accepting state with probability p acc ≥ 2/3, and analogously for NO instances.

Definition
The following definition introduces graphs whose vertices are labeled by Hilbert spaces and edges are labeled by unitaries between these spaces. A ULG is thus simply an undirected graph whose edges are labeled by unitaries and the vertices by Hilbert spaces. Note that the edge labeling introduces a natural sense of direction corresponding to U (as opposed to U † ). For this purpose we regard the edges as tuples-preserving their order-instead of sets, despite working with undirected graphs. Specifically, for an edge e = (a, b) with unitary U, we follow the convention that U is applied when going from a to b. To facilitate notation, we write these edges with associated unitaries as (a ↔ b, U) and call them simply rules R : = {(a ↔ b, g((a, b))) : (a, b) ∈ E}.

Definition 35. A unitary labeled graph (ULG) is a triple
We know that adding self-loops leaves a graph Laplacian invariant. Since simple ULGs never have nontrivial self-loops-referring to the attached edge unitary-we will for the sake of uniqueness implicitly disallow simple ULGs to have self-loops at all.

Proposition 39. Take a ULG G with vertices S and rules R. Let the associated Hamiltonian H = H(G) be as defined in definition 38. Then H is a Hermitian operator on the total Hilbert space H tot := H S ⊗ H and invariant under replacing each rule (a ↔ b, U) with the corresponding inverse rule (b ↔ a, U † ). In particular, the definition of H does not depend on the choice of the basis {|e i }.
Proof. First observe that the Hilbert spaces attached to any of the vertices s ∈ S are isomorphic, since the associated graph is connected. The operator H is Hermitian by construction. Observe further that hence the claim follows.
Note that one can extend this notion to a ULG with non-connected associated graph components in a straightforward manner, by simply summing over all disjoint subsets. This yields a block-diagonal associated Hamiltonian.

Semi-Classical Unitary Labeled Graphs
Definition 40. Take a connected ULG where n := dim H, and let H be its associated Hamiltonian. If there exists a unitary operator W and a graph Laplacian ∆ such that W † HW = ∆ ⊗ 1 n , then we call the ULG semi-classical.
This naturally depends to the case of non-connected ULGs. The following lemma is an important result for analysing the spectrum of our ULG Hamiltonian.

Lemma 41. Any simple ULG is semi-classical.
Proof. Denote the set of vertices with S and the rules with R. If the ULG has disjoint components, H is block-diagonal, hence we can assume without loss of generality that the ULG is connected and all its vertices have isomorphic attached Hilbert spaces H. Pick an arbitrary vertex a and denote the nearest neighbor and edge set with S a and R a , respectively. Using proposition 39, rewrite R in a form where a only has outgoing edges, and write where R denotes all the rest of the terms. Define Observe that all terms in the product commute. Then W † a RW a = R and For the terms in H n , regard a particular edge b, c ∈ S a with unitary U. For some basis vector |e , where we have used the fact that for simple ULGs, the product of unitaries along a closed cycle is 1, i.e. U † c UU b = 1. By a similar argument, we can show that the rules in H nn change their unitary by a factor of U b when outgoing, or U † b when incoming, respectively. We are left with a ULG G where every edge connecting to a and connecting neighbors of a is classical, i.e. the edge unitary is the trivialized to the identity operator 1.
We need to trivialize the graph in a specific order, e.g. following a breadth-first search along any spanning tree on G. The above argument is applied to the root of the tree, which shows the induction start. Assume now that all edges to and including depth n are classical, and we want to proof the next step, depth n + 1. It is evident that conjugating a depth n vertex a by a unitary W a leaves all edges between depth ≤ n vertices classical. As shown above, all edges connecting depth n and n + 1 vertices are trivialized, as is any edge connecting depth n + 1 vertices by simplicity of the QSS. This concludes the induction.
Remark 42. By lemma 41 and using the same notation as in the proof, the diagonalizing unitary W = a∈S W a , where the order in the product is such that the succinct W a are constructed from G, G , G , . . ..
Abusing notation, it is clear that the obtained Laplacian for a ULG G is in fact the Laplacian of its associated graph, i.e. W † H(G)W = ∆(G) ⊗ 1.
Lemma 43. Let G be a simple ULG with vertices S and rules R.
Proof. Because the ULG is simple, by lemma 41, there exists a unitary W and a classical Laplacian ∆ such that W † HW = ∆ ⊗ 1 n , and hence ker H = ker ∆ ⊗ 1 n . By lemma 25, the ground space of ∆ ⊗ 1 n has a basis given by |Φ i,j := 1 |V i | s∈V i |s ⊗ |e i , i = 1, . . . , N and j = 1, . . . , n .
Observe that which can be easily verified.

Kitaev's Geometrical Lemma for Unitary Labeled Graphs
Analogous to section 2.6, we extend the notion of penalizing vertices to ULGs. First we state an immediate corollary from lemma 30. Proof. G is simple and H(G) has the same spectrum as ∆(G), up to multiplicity. Now use lemma 30 on ∆(G) + P(G, P).
A more interesting case is when one does not want to penalize the entire Hilbert space attached to a vertex, but only a subspace. This is captured in the following lemma. Proof. First note that the U ij are well-defined, since the ULG is simple and connected. Construct W such that the root of the spanning tree is one of the penalized vertices, namely r with projector Π r . Then where the R p are the product of unitaries connecting vertex p with the root r. Now apply lemma 30.

Thue Systems
Let us briefly recall the idea behind classical Thue systems, also known as string rewriting systems.
Definition 46. A Thue system-TS for short-is a tuple (Σ, R) of a finite alphabet Σ and a finite symmetric binary relation R ⊂ Σ * × Σ * , where Σ * := ∞ i=0 Σ i denotes the set of all strings over the alphabet Σ.
The binary relation R is usually written as a set of rewrite rules a ↔ b and they are naturally extended to other strings in Σ * : if a ↔ b ∈ R, then c ↔ d in R if there exist u, v ∈ Σ * such that c = uav and d = ubv. Thue systems with this extension-denoted by R * -are a special case of abstract reduction systems and well-studied as computational models-see [Tho10].
Thue systems are multiway systems, i.e. starting from an initial string a ∈ Σ * , exactly one substring is replaced at a time-in particular, this means that there might be branching points when the substitution is not unique. For our purpose, it is enough to consider length-preserving substitutions, i.e. any space Σ i should be invariant under R; we denote the length of any string s with |s|. In this case, there exists a natural representation of the Thue system over strings of length N as a finite, undirected and not necessarily connected graph.  It is immediate to see this one-to-one correspondence between connected associated graph components and irreducible evolutions.
We want to introduce a sense of locality to TS relations.
Observe how this definition is well-defined, as we required R to be finite, cf. definition 46.

Quantum Thue Systems and their Hamiltonian
We begin by generalizing the notion of Thue systems to the case where our alphabet has special quantum symbols, with rewriting rules being unitary operators between them. To work with these two alphabets, consider Σ = Σ cl Σ q as the union of two disjoint-classical and quantum-alphabets. For a string s ∈ Σ * , write |s| q for the number of letters from Σ q in s. This allows the following definition.
Definition 52. A quantum Thue system (QTS) is a quadruple (Σ, R, {U r } r∈R , H) of a bipartite alphabet Σ = Σ q Σ cl , a relation R, a unitary operator U r for each rule r ∈ R and a finite-dimensional Hilbert space H with the following properties: • |·| q is invariant under any rule r ∈ R, The invariance of |·| q under a rule r = s 1 ↔ s 2 allows to abbreviate |r| q := |s 1 | q = |s 2 | q , which indicates the number of quantum letters the rule r acts on.
We can again use the QTS to form sequences of strings: starting from a string s ∈ Σ * , apply rules consecutively as for TSs. In addition, to each string s ∈ Σ * , we attach a Hilbert space H s := H ⊗|s| q : starting from some vector v ∈ H s , each time a rule r is applied to a substring, the corresponding unitary acts on the subspace wherever the rule matches, acting as identity everywhere else.
Analogous to fig. 10, we can build a graph for strings of length L for any QTS-where each edge is labeled by the acting unitary. The following lemma should therefore not come as a surprise.
Lemma 53. Any k-local QTS (Σ, R, {U r }, H) restricted to strings of a certain length N ≥ k is also a ULG. Furthermore, the associated Hamiltonian for strings of length N is isomorphic to a geometrically k-local and translationally-invariant Hamiltonian on a chain (C Σ ⊗ H) ⊗N with the same spectrum.
Proof. We explicitly define the ULG (S, R ) for strings of length N ≥ k. The vertex set S := Σ N is straightforward. For every r ∈ R denoted s 1 ↔ s 2 , define the ULG edges (us 1 v ↔ us 2 v, 1 ⊗|u| H ⊗ U r ⊗ 1 ⊗|v| H ) for any u, v ∈ Σ * -potentially extending U r to H ⊗N −k acting trivially on classical substrings-such that us 1 v ∈ Σ N . It is straightforward to verify that this defines a valid ULG.
The second claim follows from the canonical isomorphism between the two Hilbert spaces i.e. a simple rearrangement. Conjugating the associated Hamiltonian of the ULG with this isomorphism proves the second claim.
As QTSs are also ULGs, we will be-without always specifying the string length restriction explicitly-using ULG terminology for QTSs, e.g. associated Hamiltonians, irreducible evolutions or speak of QTSs being simple.
Lemma 54. Let the setup be as in lemma 53. Then the isomorphism extends to a Hamiltonian on the chain (C Σ cl ⊕ (C Σq ⊗ H)) ⊗N with the same spectrum up to multiplicities.
Proof. Any rule on a classical substring acts identically on H, hence on the set of Hamiltonians with this property a conjugation of the isomorphic Hamiltonian in lemma 53 H with the projector (C Σ ⊗ H) ⊗N −→ (C Σ cl ⊕ (C Σq ⊗ H)) ⊗N is an isomorphism. The projector preserves the spectrum, up to multiplicities.
In the following, we often gloss over the fact and simply assume that the associated Hamiltonian of a QTS is local in the sense of lemma 54. Observe however that a ULG induced from a QTS is not necessarily simple, and it is easy to find a counterexample.

Quantum Thue Systems as a Computational Model
To use a QTS for computation, we need to mark some strings that have special meaning, e.g. are input or output of the computation.
Definition 55. For a QTS with alphabet Σ and Hilbert space H, a marker is any tuple (s, π) where s ∈ Σ * and π is a projector on some subspace of H ⊗|s| q . The set of markers on strings of length k-called k-local markers-is denoted M (k) , and M := k M (k) .
That is, we can specify a string s and a configuration of the quantum part of this string as a specific state in the computation.
Definition 56. Let (Σ, R, {U r }, H) be a QTS and L = (L YES , L NO ) a promise problem. We introduce an encoding function enc : L → Σ * , input and output markers (s inp , Π inp ), (s out , Π out ) ∈ M (n) for some n ∈ N. Then the QTS • rejects an instance l ∈ L if there exists a chain of rules in R connecting enc(l) with two strings containing s inp and s out , respectively, and ψ| Π out + U † Π out U |ψ ≥ -here U = U(l) stands for the product of unitaries along this chain, and Π inp and Π out are extended trivially to the entire chain in case |s inp | q > |enc(l)| q or |s out | q > |enc(l)| q .
• decides L if for all l ∈ L, l is accepted if l ∈ L YES , and rejected for l ∈ L NO .
The rejection and acceptance threshold will depend on the class of promise problems that we want to decide. In particular, we want to allow this threshold to scale with the problem instance size, i.e. = (|l|), and thus indirectly with the time that a computation can take, as specified in the following definition.
Definition 57. Let Q be a QTS that decides L. For an instance l ∈ L, the history state is defined as the irreducible evolution of the ULG containing enc(l).
For a QTS with unambiguous transition rules-i.e. where the history state is a line-the size of the history state simply corresponds to the runtime of the underlying computation.
We now want to describe a simple example for a QTS which can decide the following simple promise problem.

Instance. Natural number n ∈ N.
Output. YES if n even, otherwise NO. Proof. The proof is straightforward. Starting on the encoded input enc(n), the TS generates a sequence so there always exists a chain of rules that connects enc(n) with a string containing s out . The decision is thus made by the content of the quantum part: for n applications of the rule, starting from a vector |v ∈ C 2 , we apply R n times. For Π ⊥ out = |0 0|, it is thus immediate to calculate , and the claim follows.

A Special Kind of Quantum Thue System
We have seen that QTS can be used to answer simple problems. On the other hand, a more interesting question is whether there exists a universal QTS which can run any computation of a certain class of promise problems C, i.e. is complete for C. Of particular interest in this setting is the question about scaling of the defining parameters for such a QTS: how big is the alphabet, what is the locality and how does the string length of the vertices in the history state scale, i.e. for a promise problem L ∈ C, does there exist a function f such that for l ∈ L, | enc(l)| = O(f (|l|))? And what about the size of the history state?
For the complexity class BQEXP, we have the following lemma. W4 For all other irreducible evolutions M = M l , at least one of the following is true: • M is not bracketed, • M can be broken up into O(g(l))-sized connected parts-where g(l) = poly(j(l))each of which containing at least one string containing an invalid character tuple not in A. The proof will be a simple combination of our previously-collected results.

Hardness Result
1. Let L be a promise problem in QMA EXP . By definition 13, the verification of L is a BQEXP problem. By Fact 12, we can assume without loss of generality that the accept and reject probabilities in definition 56 are 1 − and , respectively, where = 1/3 poly |l| to be specified below, where |l| denotes the length of the problem input.
2. By corollary 73, we can thus create a QTS with properties as in lemma 60 that verifies L: more specifically, for an instance l ∈ L and by item W2, we know that this QTS verifies l on strings of length j(l).
3. By lemma 53, the QTS restricted to strings of length j(l) is also a ULG. Denote the Hamiltonian associated to this ULG by H l , block-diagonal in the irreducible evolutions.
With Γ denoting the alphabet from definition 63 and j(l) denoting the number of systems, we define a Hamiltonian on the Hilbert space (C Γ ) ⊗j(l) as follows: where • P boundaries penalizes any non-bracketed string-cf. item W3, • B heads acting on a string |s ∈ (C Γ ) ⊗j(l) gives a bonus of |s| h , according to how many head symbols there are in s, • P penalizes any character tuple not in A, • p(l) is a function used to scale the penalties, which will be specified later, but-keeping remark 18 in mind-must not exceed p(l) = poly j(l).
The encoding and output penalties Π inp = Π out = |1 1| are translationally-invariantly extended to the entire chain, i.e. on Hilbert space (H cl ⊕ H q ) ⊗j(l) , we act with the 2-local projector and analogously for P out .
Completeness. Assume l is a YES-instance, and denote the history state as an eigenvector of H l with |Ψ l , which by item W3 is also an eigenstate of B heads , P boundaries and P. A direct calculation yields By item W2, we further know that at least one vertex in |Ψ l has the in-and output substrings s inp ,s out , and because |s inp | h = |s out | h = 1, there is at most one such substring match for every vertex. As an upper bound, we can thus assume that the penalty applies exactly once in every vertex-i.e. Ψ l | P in/out |Ψ l ≤ /|M l |, and conclude Ψ l | H |Ψ l ≤ −1 + /|M l |.
Soundness. Assume l is a NO-instance. We need to lower-bound the lowest energy eigenvalue of H, and since we know that H is block-diagonal in the irreducible evolutions, we can bound each block separately-the history state block given in item W3 and any other irreducible evolution block characterized by item W4. Without loss of generality we can therefore assume that |ψ is completely supported on a single block of H (but not necessarily an eigenvector).
We can now apply lemma 45 to the last expression. By item W2 and definition 56, we obtain a bound ψ| H l + P in/out |ψ ≥ (1 − )/|M l | 3 . Observe how this lower bound scales ∝ 1/|M l | 3 , whereas for YES-instances the upper bound scales ∝ /|M l |. Since we want the lower bound for NO-instances-β-and the upper bound for YES-instances-α-to be separated by at least some β − α = Ω(1/ poly j(l)), cf. definition 16, we need to amplify the accepting probability to = O(1/|M l | 3 ) = O(1/ poly j(l) 3 ). Observe that this does not exceed the allowed amplification, which is limited to O(1/3 poly |l| ).
We proceed to show lower bounds for all other minimum valid evolutions, following item W4. Assume we are in a block with 0 heads, which is well-defined by item W1. The bonus term B heads vanishes on this subspace while all other operators in eq. (3) are positive semi-definite, so we obtain a lower bound of ψ| H |ψ ≥ 0 for any state solely supported there.
Analogously, non-bracketed blocks can be bounded by a direct calculation, as P boundaries penalizes all vertices equally: any non-bracketed state |ψ for a block with h heads satisfies ψ| H |ψ ≥ −h + p(l). It thus suffices to set p(l) ≥ j(l), as the number of possible heads on a string is limited by its length, i.e. h ≤ j(l).
The last blocks remaining are the ones with g(j(l))-sized connected parts with invalid tuples, where g(n) = poly n as defined in item W4. First observe that this part of the ULG is not necessarily simple, so we remove the transitions which allow nontrivial loops without breaking the graph up into multiple parts. We then split this graph into g(j(l))sized connected components by temporarily removing further edges from it, which yields a Hamiltonian for a sparser graph H . Since adding any edges back in corresponds to adding a positive semi-definite matrix to H , it suffices to lower-bound the spectrum of H on this subspace. Note that we do not remove vertices or change any penalties, so in particular all the diagonal operators in eq. (3) remain untouched.
Hence assume |ψ has support in one of the slices of size upper-bounded by g(j(l)) with h heads, such that at least one vertex picks up a penalty from P. Again applying lemma 45, we obtain a bound ψ| H |ψ ≥ ψ| H |ψ ≥ −h + p(l) × Ω(1/g(j(l)) 3 ). We therefore have to scale p to e.g. p(l) ≥ g(j(l)) 5 , which is still allowed by remark 18 (namely, p is polynomial in l). This concludes the proof.
What remains to be shown is the existence of a QTS as in lemma 60. The next section will provide an explicit construction, finalizing the proof of our main result. This construction is meant as a proof-of-concept-the model we present can be modified in numerous ways and is likely not optimal. It does, however, make heavy use of our newly-developed methods such as branching, thus reducing the local dimension of the underlying Hamiltonian to 42, as compared to the hitherto best result by [GI13] which is larger by at least several orders of magnitude.

Introduction
Turing's Wheelbarrow is our constructive proof of a QTS with properties as mentioned in lemma 60. The QTS will be optimized for local dimension and locality-every transition rule will be 2-local and act on strings from an alphabet Γ with 48 characters. We describe the QTS by explicitly writing out all transition rules of the QTS and then prove the properties from lemma 60. Finally, in section 7.7 we reduce its local dimension down to 42.
The conceptual idea of the Wheelbarrow QTS is the following. To build a QTS which can decide a promise problem L ∈ BQEXP, we first prefix the original circuit C l deciding an instance l ∈ L by another circuit which verifies that a number of ancillas necessary for C l are correctly initialized to |0 . On some extra ancillas, we write out the problem instance l, and also leave an unconstrained section of qubits available for C l . This witness section, problem instance and the leftover ancillas are then fed into C l , and the output wire contains |out = cos((p a + p out )/3) |0 + sin((p a + p out )/3) |1 for the amplitudes p a -all ancillas being 0-and p out -the circuit output of C l on the ancillas and problem instance. This overall circuit, denoted C l , is shown in fig. 11.
It is clear that this augmented circuit family (C l ) l∈L is in the same uniformity class as the original circuit family (C l ) l∈L , and we can thus define these circuits with output |out to be a separate BQEXP problem L . By lemma 33 and its proof, this new promise problem can be decided by a family of BQEXP QRMs with the special property that the head motion and all internal QRM states are classical-cf. fig. 7.
Using Solovay-Kitaev [NC10,appx. 3], the head unitary of such a QRM can in turn be efficiently rewritten as a circuit R using the following small set of gates.
Remark 62. Toffoli, Swap and a classically-controlled quantum-universal unitary together with at least one classical and quantum ancilla is universal for quantum computation and exactly universal for classical computation.
In particular, S-K tells us that since the head circuit R = R(l) depends on the problem instance l-as it needs to write the instance out-and the size of this circuit is |R(l)| = poly |l|. The Wheelbarrow QTS which we construct will then be able to execute this head cyclically on a ring of qubits, where the execution is halted once the QRM terminates: as the QRM motion is deterministic, the runtime will be exp poly |l|-bounded, as required for a BQEXP computation.
The first step is to bootstrap the QRM head U. Starting from an initially empty string, we use a number of rules to translate the string length N into a circuit description of U on the left side of the string. This section will have size ≈ log 6 N , as we need 6 instruction symbols-a classically-controlled unitary U , Toffoli T , ancilla-checking symbol A , swap S , left-shift symbol and halt H . The remaining right side of the string will act as classical and quantum tape that the computation runs on. Fig. 12 outlines how a circuit can be translated into such a 6-ary circuit description.  Figure 11: An augmented quantum verifier circuit. The circuit uses one ancilla |0 to verify that as many ancillas as necessary for the computation are set to 0, rotating the single guaranteed |0 ancilla by π/3 if this is not the case. On some ancillas, the problem instance l is written out. Another rotation by π/3 is applied depending on the output of the verifier circuit. The overall output state then takes the form |out = cos((p a + p out )/3) |0 + sin((p a + p out )/3) |1 . Figure 12: Example on how to translate a sample circuit section into a program description, where U 0 , U 1 and U ? can stand for any unitary gate. Starting from the top left, the description here is 1 0 0 1 0 0 0 0 1 ? . The dashed line stands for a normal identity 0 0 , as Cnot 2 = 1. The rhombus is a special symbol that shifts the current gate position up by one; as in each successive step the position moves down by one by default, it suffices to only have this one special shift symbol. The last gate is a special identity to be used to initialize ancillas and penalize a section of the output. Figure 13: The two actions that can be performed by the wheelbarrow construction. On the left, we apply a gate U 0 corresponding to the rightmost program bit 0 . The ring of qubits is then rotated by one, which is the default downwards shift as mentioned in fig. 12. On the right, the special action of the symbol is depicted: it signalises the rightmost qubit to move back to the left side. After either action, the program string is rotated by one.
The QRM is then executed: for every round, a program bit is taken from the left side of the string, moved towards the tape and then applied to the leftmost two data qubits. The leftmost data qubit is then picked up and carried to the right, where it is deposited. The revert action is similar, only that the rightmost data qubit is picked up and moved to the left of the tape. Fig. 13 illustrates both operations. The execution runs until the underlying ring machine terminates, which can be determined using a special halt operation H which only proceeds if the tape data is not in a halting configuration.
This also explains the choice of Turing's Wheelbarrow as name for this QTS: qubits and program symbols are moving across the tape in two cyclic motions, mimicking a busy worker carrying and depositing information in a wheelbarrow.

Notation
For convenience, we define a special notation to describe the construction of Turing's Wheelbarrow. We begin by introducing the alphabet and tape. The number of alphabet characters can be further reduced to 39, 3 of which are quantum, see corollary 73. For reasons of clarity, we use a slightly larger alphabet in this construction.
We will generally use the letters x, y, z as placeholders for program symbols-denoting any of the symbols U , T , A , S , H , as x , or alternatively U , T , A , S , H , as x , which is always clear from the context. The symbol U encodes a classically-controlled unitary, T a Toffoli, A an ancilla, S a Swap, H a halt and a special tape revert symbol. We now introduce the notation for transition rules.
Definition 64. We write a transition rule xy ↔ zw of a quantum Thue system as The blue shading is used to indicate the location on the tape where the transition rule is applied. Note that, by construction, transition rules are symmetric, i.e.
x y z w is equivalent to z w x y .
If the first rule is associated with a nontrivial unitary U, the inverse rule is associated with the adjoint U † .
As in definition 46, we never need to write out the values of the qubits anywhere. In fact, the only place where the associated Hilbert space comes in is when we want to apply a quantum gate to the qubits (see section 7.3.5). As an example, consider the action of swapping two neighboring qubits. The Thue system itself does not notice this, e.g. we would have a transition with an explicit comment on the Hilbert space unitary, i.e.

a a a a
where the associated Hilbert spaces are swapped with U = Swap.
To emphasize that the subspaces are in fact swapped, we generally use the letters a, b, c, d to label different quantum subsystems. This is only to facilitate notation! In principle, we could stick to the letter a and write out the swap action for every transition rule where this is relevant. But because we believe it is easier to read and most of the nontrivial unitaries that we use are swaps, we simply write a b b a which is self-explanatory.

Transition Rules and History State
The following table contains a list of all transition rules, visualized from a starting string of the form a c a c c . The horizontal direction corresponds to space while the time flows from top to bottom. By default, the unitary associated to any rule-if not mentioned otherwise-is the identity. Apart from Swap operations, the only nontrivial unitary appears in the computation step in section 7.3.5.
Observe that there are many possible local ambiguities within the history state, which we analyze in detail in section 7.4.

Initialization
Left hand side has a sweeper , right hand side an inactive ghost , and all middle symbols are qubits a or data bits c ∈ { 0 , 1 }, which are opaque for the ghosts. We let the sweeper move through all middle symbols. This allows a dynamic "initialization" of the tape: if the sweeper bumps into any symbol that is not a qubit, data bit or inactive ghost, we can penalize the configuration, singling out the proper history state. Once the sweeper reaches the ghost at the right boundary, it activates the ghost to and transitions to the box .

Ghost
The ghost symbols act as general "carriage return" symbols. If there is an extra head symbol on the tape, the ghost is inactive ( and ). The ghost can itself carry the head flag, in which case we call it active and denote by or . The white active ghost can either turn itself into a head symbol on the left hand side, or activate the boundary. On the right boundary, it oscillates between white and black. This construction saves us a lot of symbols, since we only ever need to specify special right-moving heads, whereas the left movement of the head state is done generically by the ghost. We will often gloss over inactive ghost transitions and assume the ghost just "moves out of the way" as necessary.
Ghosts can change color on the right boundary. Since the black ghosts and are static, any incoming head from the left can detect when it has reached the boundary as it will encounter a black ghost.
White ghosts can move through all static symbols, but not through heads. * * * *

Base-6 Counter
We count in base 6 through the sequence T , U , A , S , H , -encoding a Toffoli, classically controlled unitary, ancilla, swap, halt or tape revert operation, respectively.
It remains to analyze the revert command, where we have a branching point for a  configuration  c a c a a c  c  c a  c a a c  c  c a  c a a c  c c a c a a c  c  c a c a a c  c  c a c a a c c . . .
Observe, however, that all that could happen is that the tape symbol is carried to the right, where it is dropped next to the boundary ghost . The ghost is activated and moves back to , where it deactivates. The branch doe not continue further, as there is no transition out of a or c . This increases the history state size by some small constant ≤ 2.
We define the set of tuples A as all the possible character pairs that appear in this history state-including all branches-in table 3. This exhaustive analysis of all possible branching points in the history state allows us to conclude the following corollary.

Simplicity of Turing's Wheelbarrow
Let us briefly recall the idea behind simplicity in the context of QTSs. A QTS is called simple, if, for any two strings connected by more than one chain of transitions, the product of unitaries along this chain is identical. Equivalently, we can show that there are no loops in the graph connecting any strings. Regarding the QTS transition rules for Turing's Wheelbarrow, as constructed in the last section, it is easy to see that it will not be simple. However, for our purposes, it suffices to proof the following lemma.
Lemma 70. Each bracketed string in Turing's Wheelbarrow with at least one head either belongs to the history state, which is simple, or to a O(poly n)-sized valid evolution with illegal pairs. Proof. As no transition rule ever changes the number of heads or position of brackets, the distinction is well-defined. We can analyse each separately.
One head. We can exclude strings with illegal pairs right away. Furthermore, we can disregard configurations of non-head characters which are just allowed because there is a head symbol or ghost between them, such as a c , as moving the head either way (which is possible, since there is only one of them) transitions to an illegal pair.  The row is the first character, the column the second-e.g. is allowed, whereas x is not. c can be 0 , 1 , and x stands for any program bit U , T , A , S , H , or . † only allows the combination T , U , U , U and U . * only allows the combination allowed by the gates, i.e. T c , U c , A a , A 1 , S c , S a and H 0 . Observe how the lower right block is completely empty, as there can only ever be one head on the tape. So, disregarding any head and ghost state on the string for now, the most general nonhead-non-boundary string compatible with table 3 is It is straightforward to see that evolving this configuration backwards will transition to an illegal pair, if either • B has multiple s, or and at least one , or neither or .
• A does not match the string length log 6 n. Decrementation can only start if the substring A starts with the halt symbol H , so it cannot happen that we start decrementing a rotated number, e.g. U H A A S T instead of H A A S T U , which would translate into different lengths.
Evolving this string forward then reaches the computation part, and in case the pattern of classical and qubit states in B does not match the one required for the encoded gates in A we again have an illegal pair.
We are left with the history state, and it suffices to check any transition rule containing a nontrivial unitary attached, which by construction is the computational step only, i.e. a ä a a .
Following the transitions forward to the next such transition, by construction, the encoded Turing machine evolution is reversible, hence there is no loop as the Turing machine changes the classical content of the tape in section B.
Multiple heads. None of the heads can pass through each other. As further boundary markers such as , and are immobile and opaque and there exists no transition out of or if not left of a boundary, we can without loss of generality assume that the tape is bracketed by either of , , , , or possibly no opaque symbol if our subsection lies at the tape ends.
If there are h ≥ 2 head symbols on the tape, a simple argument allows us to slice the graph up into poly(j(l))-sized parts: first observe that following any of the heads-with potential intermediate transitions-sweeps the entire width of the string. For any configuration of the first h − 1 heads, the last head will thus necessarily bump into the h − 1 st within O(j(l)) steps. The same argument shows that there can be at most one ghost on the tape.

Special Properties
Proof of lemma 60. We will check the properties of lemma 60 one-by-one.
The deciding property follows by construction. The projectors Π inp = Π out = |1 1| are supposed to act on checking the first ancilla and output as seen in fig. 11, i.e. they apply to the qubit after the special identity symbol ? .
Item W1 is readily verified. Item W2. The encoding is given by the valid initial configuration enc(l) := a c a c c a N times , where N is a unary encoding of the QRM head circuit executing fig. 11 rewritten as depicted in fig. 12, and the sequence of a s and c s is such that they match the counting and computation phase. By construction, we therefore obtain, N + 4 = poly(|l|) =: j(l). Also by construction and as outlined in section 7.1, the program string on the left side of enc describes the head of a QRM writing out the circuit fig. 11. This QRM is in the same uniformity class as the original verifier's, and a constant in the size of l ∈ L. We can hence pad it-using identity gates-to get the space and runtime for the QRM right, which can be as large as poly j(l), as required for a BQEXP computation.
Both input and output markers s inp = s out = A a are 2-local, contain one head A , and Π inp = Π out = |1 1|.
Item W3 We have shown the first claim in lemma 70 and corollary 69. The rest follows by direct verification.
Item W4 We can immediately sort out the no-head and not-bracketed cases. The rest follows from lemma 70.
This concludes the proof.

Final Dimension Reduction
We want to make a few final remarks, and suggest an immediate optimization of the Wheelbarrow construction. The distinction between the quantum and classical tape symbols c and a is unnecessary, if we can ensure that there is never a quantum operation on classical symbols and vice versa. This is already proven.
The reason why we can merge these symbols is that while the QTS requires the ULG vertices to comprise only the classical alphabet symbols, we do not need to make this distinction for a ULG-as long as we can ensure that the Hilbert space dimension on each vertex in a connected component is the same. It is also clear that this does not break simplicity in lemma 70, as we always know which tape symbols are classical (the ones appearing next to classical operations, e.g. T ) and which ones are quantum (e.g. the one next to ! ). This observation allows the following optimization.
Remark 71. The Wheelbarrow construction works exactly the same when merging a with c , a with c , and a with c .
Once we have merged the symbols, there is another merge possible. We know that Toffoli and some basis-changing unitary U are quantum-universal, see e.g. [NC10,ch. 4.5]. This means that we can replace the classically-controlled unitary with such a one-qubit unitary, and apply Toffoli gates to quantum symbols as well. A similar argument as before shows that this does not break lemma 70, and we phrase the following remark.
Remark 72. The Wheelbarrow construction works when replacing the controlled unitary with a single-qubit basis-changing unitary, and extending Toffoli to work on classical and quantum tape content. This makes the symbols ! ,ȧ andä obsolete.
Including the saved symbols from the last two remarks-c , c , c , ! ,ȧ andä-we conclude with the existence proof of lemma 60. Remark 74. It is straightforward to get O(1)-interactions, i.e. removing the scaling polynomial p(l) in theorem 61 if we can locally distinguish the history state at all times. This is possible e.g. by using distinct non-head symbols on the left and right hand side of the head and penalizing invalid configuration using regular expressions as in [GI13]. This would increase our dimension by roughly 15.

Conclusion
This work was motivated by the idea of finding a simple, translationally-invariant and physically interesting system, for which the ground state energy problem is QMA EXP -hard. In [GI13], Gottesman and Irani concluded that their construction is not "particularly natural", due to the large local dimension necessary, but that the existence of some very simple QMA EXP -hard local Hamiltonian problems seems quite possible.
Our results bring us another step closer to this goal: we reprove the hardness result in [GI13] but with a local dimension of 42, whereas in [GI13]-though not explicitly specified-it was several orders of magnitude larger. To prove this result, we develop new tools and computational models which we believe are applicable to a wider range of problems.
At this point it would be interesting to see where the threshold for the translationallyinvariant local Hamiltonian problem lies: does there exist a local dimension d min , for which the problem is in BQP, or BQEXP? We have shown that d min < 42, but do not believe this to be a strict bound. We therefore encourage the interested reader to construct their own version of the Wheelbarrow, which might yield an even lower local dimension, and thus tighten our bound.
Furthermore, a lot of work recently has been done to analyze non-translationally-invariant systems, and to classify interactions with locally-varying interaction strengths, e.g. [CM13;PM15]. In contrast to our construction, the hardness results in [PM15] resemble more a tiling construction, a subject also addressed in [GI13]. It would be an interesting approach to see if these two-fundamentally quite different-results can be combined, or if there exists yet another, completely different, method of encoding computation into the ground state of a local Hamiltonian.
Finally, we want to mention that while the research focus-as outlined in table 1-quickly shifted towards the 1D variant of the problem, from a physical perspective both 2D and 3D versions of this result are still of great interest, and apart from a trivial extension of our result to higher spatial dimensions, both remain open problems.