Ground state connectivity of local Hamiltonians

Ground state connectivity of local Hamiltonians

Sevag Gharibian111Simons Institute for the Theory of Computing and Department of Electrical Engineering and Computer Sciences, University of California, Berkeley, CA 94720, USA, and Department of Computer Science, Virginia Commonwealth University, Richmond, VA 23284, USA. Email: sgharibian@vcu.edu.    Jamie Sikora222Centre for Quantum Technologies, National University of Singapore, Singapore 117543. Email: cqtjwjs@nus.edu.sg.
July 15, 2019
Abstract

The study of ground state energies of local Hamiltonians has played a fundamental role in quantum complexity theory. In this paper, we take a new direction by introducing the physically motivated notion of “ground state connectivity” of local Hamiltonians, which captures problems in areas ranging from quantum stabilizer codes to quantum memories. We show that determining how “connected” the ground space of a local Hamiltonian is can range from QCMA-complete to NEXP-complete. As a result, we obtain a natural QCMA-complete problem, a goal which has generally proven difficult since the conception of QCMA over a decade ago. Our proofs rely on a new technical tool, the Traversal Lemma, which analyzes the Hilbert space a local unitary evolution must traverse under certain conditions. We show that this lemma is tight up to a polynomial factor with respect to the length of the unitary evolution in question.

1 Introduction

Over the last fifteen years, the merging of condensed matter physics and computational complexity theory has given rise to a new field of study known as quantum Hamiltonian complexity [Osb12, GHLS14]. The cornerstone of this field is arguably Kitaev’s [KSV02] quantum version of the Cook-Levin theorem [Coo72, Lev73], which says that the problem of estimating the ground state energy of a local Hamiltonian is complete for the class Quantum Merlin Arthur (QMA), where QMA is a natural generalization of NP. Here, a -local Hamiltonian is an operator acting on qubits, such that each local Hermitian constraint acts non-trivially on qubits. The ground state energy of is simply the smallest eigenvalue of , and the corresponding eigenspace is known as the ground space of .

Kitaev’s result spurred a long line of subsequent works on variants of the ground energy estimation problem (see, e.g. [Osb12, GHLS14] for surveys), known as the -local Hamiltonian problem (-LH). For example, Oliveira and Terhal showed that LH remains QMA-complete in the physically motivated case of qubits arranged on a 2D lattice [OT08]. Bravyi and Vyalyi proved [BV05] that the commuting variant of -LH is in NP. More recently, the complexity of the version of -LH in which large positive and negative weights on local terms are allowed was characterized by Cubitt and Montanaro [CM13] in a manner analogous to Schaeffer’s dichotomy theorem for Boolean satisfiability [Sch78]. Thus, -LH has served as an excellent “benchmark” problem for delving into the complexity of problems encountered in the study of local Hamiltonians. Yet, one can also ask about the properties of the ground space itself. For example, is it topologically ordered? Can we evaluate local observables against it [Osb12]? It is this direction which we pursue in this paper.

Specifically, in this paper we define a notion of connectivity of the ground space of , which roughly asks: Given ground states and of as input, are they “connected” through the ground space of ? Somewhat more formally, we have (see Section 2 for a formal definition):

Definition 1.1 (Ground State Connectivity (Gscon) (informal)).

Given as input a local Hamiltonian and ground states and of (specified via quantum circuits), as well as parameters and , does there exist a sequence of -qubit unitaries such that:

  1. ( mapped to ) , and

  2. (intermediate states in ground space) , is in the ground space of ?

In other words, GSCON asks whether there exists a sequence of unitaries, each acting on (at most) qubits, mapping the initial state to the final state through the ground space of . We stress that the parameters (i.e. number of unitaries) and (i.e. the locality of each unitary) are key; as we discuss shortly, depending on their setting, the complexity of GSCON can vary greatly.

Physics Motivation.

The original inspiration for this work came from a recently active area in classical complexity theory on reconfiguration problems (see Previous work below for details). For example, the reconfiguration problem for 3SAT asks: Given a 3SAT formula and satisfying assignments and for , does there exist a sequence of bit flips mapping to , such that each intermediate assignment encountered is also a satisfying assignment for ? Although the classical study of reconfiguration problems is arguably mostly interesting from a theoretical perspective, its quantum variant (i.e. GSCON) turns out to be physically relevant. To illustrate, we now discuss connections to quantum memories and stabilizer codes.

Quantum memories. A key challenge in building quantum computers is the implementation of long-lived qubit systems. In low-temperature systems, one approach is to encode a qubit in the ground state of a gapped Hamiltonian with a degenerate ground space. Here, the degeneracy ensures the qubit has at least two basis states, logical and , and the gap ensures that external noise does not (easily) take a ground state out of the ground space. However, this is not sufficient — although environmental noise may not take the state out of the ground space, it can still alter the state within the ground space (e.g. inadvertently map to ). Thus, making the typical assumption that errors act locally, it should ideally not be possible for to be mapped to through the ground space via a sequence of local operations. This is precisely the principle behind Kitaev’s toy chain model [Kit01], and the motivation behind the toric code [Kit03] (see also [KL09]). This notion of how “robust” a quantum memory is can thus be phrased as an instance of GSCON: Given a gapped Hamiltonian , a ground state to which the quantum memory is initialized, and an undesired ground state , is there a sequence of local errors mapping the state of our quantum memory through the ground space from to ?

Stabilizer codes. Roughly, a stabilizer code [Got97] is a quantum error-correcting code defined by a set of commuting Hermitian operators, , such that and for all . The codespace for is the set of all satisfying for all . In other words, defining as the projection onto the eigenspace of , the codespace is the ground space of the positive semidefinite Hamiltonian . Typically, errors are assumed to occur on a small number of qubits at a time; with this assumption in place, the following is a special case of GSCON: Given and codewords and , does there exist a sequence of at most local errors mapping to , such that the entire error process is undetectable, i.e. each intermediate state remains in the codespace?

Results.

Having motivated GSCON, we now informally state our results.

Theorem 1.2 (See Theorem 5.1 for a formal statement).

GSCON for polynomially large (i.e. for polynomially many local unitaries ) and (i.e. -qubit unitaries) is QCMA-complete.

Here, QCMA is QMA except with a classical prover [AN02]. See Section 2 for a formal definition. Theorem 1.2 says that determining whether there exists a polynomial-size quantum circuit mapping to through the ground space of is QCMA-complete.

Theorem 1.3 (See Theorem 6.1 for a formal statement).

GSCON for exponentially large (i.e. for exponentially many local unitaries ) and (i.e. -qubit unitaries) is PSPACE-complete.

Theorem 1.3 says that determining whether there exists an exponential length sequence of -qubit unitaries mapping to through the ground space of is PSPACE-complete.

Finally, in Section 7 we define a succinct variant of GSCON, called SUCCINCT GSCON, in which the Hamiltonian has a succinct circuit description, and the initial and final states and are product states. We show:

Theorem 1.4 (See Theorem 7.4 for a formal statement).

SUCCINCT GSCON for exponentially large (i.e. for exponentially many local unitaries ) and (i.e. -qubit unitaries) is NEXP-complete.

As Theorem 1.4 follows from techniques similar to Theorems 1.2 and 1.3, we give only a proof sketch of it in Section 7.

We remark that the choices of and above are key to our results. For example, Theorem 1.2 holds for any constant (see remarks after its proof); however, for (for the input size) the problem is likely no longer in QCMA, as the prover cannot send a classical description of each local unitary. Similarly, attempting to extend Theorem 1.3 by setting appears problematic, as then any intermediate state in the unitary evolution seems to require exponential space to represent. This latter problem is, however, in NEXP. We thus conjecture that it is actually NEXP-complete.

Proof techniques.

Our results rely on a new technical lemma called the Traversal Lemma, as well as the use of -nets and -pseudo-nets (also known as improper covering sets). We now outline the proof techniques behind Theorem 5.1 (QCMA-completeness) in more detail; using similar ideas, Theorems 6.1 (PSPACE-completeness) and 7.4 (NEXP-completeness) follow analogously.

Specifically, we outline both QCMA-hardness and containment in QCMA. Beginning with the former, the central idea behind the construction is as follows. Let be an arbitrary QCMA verification circuit, and let be the local Hamiltonian obtained from via Kitaev’s circuit-to-Hamiltonian construction [KSV02] (see Lemma 2.4 for Kempe and Regev’s -local version [KR03]). Then, we design the input Hamiltonian to GSCON so that “traversing its ground space” is equivalent to simulating the following protocol: Starting from the all-zeroes state, prepare the ground state of (which can be done efficiently since is a QCMA circuit), and subsequently flip a set of special qubits called GO qubits. This latter step “activates” the check Hamiltonian , which now “verifies” that the ground state prepared is indeed correct. Finally, uncompute the ground state to arrive at a target state of all-zeroes except in the GO register, which is now set to all ones.

To prove correctness of this construction, our main technical tool is a new lemma we call the Traversal Lemma (Lemma 4.2), which analyzes the Hilbert space a local unitary evolution must traverse in certain settings. Specifically, define two states and as -orthogonal if for any -local unitary , we have . In other words, any application of a -local unitary leaves and orthogonal. Then, the Traversal Lemma says that for -orthogonal states and , if we wish to map to via a sequence of -local unitaries, then at some step in this evolution we must leave the space spanned by and , i.e. we must have “large” overlap with the orthogonal complement of and . To prove the Traversal Lemma, we use a combination of the Gentle Measurement Lemma of Winter [Win99] and an idea inspired by the quantum Zeno effect.

As the Traversal Lemma is a key technical contribution of this paper, we also study its properties further (i.e. independently of its application to our complexity theoretic results). For example, we show the lemma is tight up to a polynomial factor in the number of unitaries. To do so, we give a pair of -orthogonal states , with the following property: For any , we construct a carefully selected sequence of -local unitaries mapping to , such that at any point in this mapping, the overlap with the orthogonal complement of and is at most . We also delve further into the study of -orthogonality, including giving an intuitive characterization of the notion.

Finally, containment of GSCON in QCMA is shown via a simple and natural verification procedure, wherein the prover sends a classical description of the local unitaries , and the verifier prepares many copies of the starting, final, and all intermediate states and checks that all required properties hold. To make this rigorous, we construct an -pseudo-net, which allows us to easily discretize the space of -dimensional unitary operators for any . Such pseudo-nets come with a tradeoff: On the negative side, they contain non-unitary operators. On the positive side, they are not only straightforward to construct, but more importantly, they have the following property: Given any element in the pseudo-net, there are efficient explicit protocols for checking if is close to unitary, and if so, for “rounding” it to such a unitary.

Previous work.

To the best of our knowledge, our work is the first to study reconfiguration in the quantum setting. In contrast, in the classical setting, such problems have recently received much attention. In particular, our work was inspired by the paper of Gopalan, Kolaitis, Maneva, and Papadimitriou [GKMP06], which shows that determining whether two solutions and of a Boolean formula are connected through the solution space is either in P or is PSPACE-complete, depending on the constraint types allowed in the formula. (Note: A minor error in Reference [GKMP06] was recently corrected in the work of Schwerdtfeger [Sch13].) More recently, Mouawad, Nishimura, Pathak and Raman [MNPR14] studied the variant of this problem in which one seeks the shortest possible Boolean reconfiguration path; they show this problem is either in P, NP-complete, or PSPACE-complete. In this sense, our definition of GSCON can be thought of as a quantum generalization of the problem studied in Reference [MNPR14]. More generally, since the work of Reference [GKMP06], a flurry of papers have appeared studying reconfiguration for problems ranging from Boolean satisfiability to vertex cover to graph coloring [CvdHJ08, BC09, BJL11, CvdHJ11, FHHH11, IDH11, Bon12, IKD12, IKOZ12, KMM12, Sch13, BB13, MNR13, MNPR14, MNR14].

Significance to complexity theory.

We now discuss the motivation behind GSCON from a complexity theoretic perspective. We begin by focusing on QCMA, which is a natural class satisfying . Although QCMA was introduced over a decade ago by Aharonov and Naveh [AN02], we still have an unfortunately small number of complete problems for it. In particular, to the best of our knowledge, the following is an exhaustive list:

  • Does a given local Hamiltonian have an efficiently preparable ground state [WJB03]?

  • Does a given quantum circuit act almost as the identity on computational basis states [WJB03]?

  • Given a braid, can it be conjugated by another braid from a given class such that the Jones polynomial of its plat closure is nearly maximal [WY08]?

  • Given a continuous-time classical random walk on a restricted class of graphs, and time , do there exist vertices and such that the difference of the probabilities of being at and is at least  [JW06]?

  • Given a quantum circuit accepting a non-empty monotone set, what is the smallest Hamming weight string accepted by  [GK12]?

In this regard, the pursuit of natural complete problems for QCMA has arguably proven rather difficult. Our results add a new, physically-motivated problem to the short list of QCMA-complete problems.

Second, a common focus in quantum complexity theory has been the problem of estimating the ground state energy of a given local Hamiltonian (see, e.g. [GLSW14] for a survey). However, less attention has been given to the complexity of determining other properties of local Hamiltonians. For example, Brown, Flammia, and Schuch showed [BFS11] that computing the ground state degeneracy and density of states for a local Hamiltonian is #BQP-complete. Gharibian and Kempe showed [GK12] that determining the smallest subset of interaction terms of a given local Hamiltonian which yields a high energy ground space is cq--complete. Ambainis has shown [Amb14] (among other results) that evaluating local observables against a local Hamiltonian is -complete, and that determining the spectral gap of a local Hamiltonian is in . Continuing in this vein, our work initiates a new direction of study regarding properties of local Hamiltonians beyond estimating the ground state energy, namely the study of ground state connectivity.

Finally, regarding the use of our proof techniques in the study of quantum algorithms and verification procedures, we hope the Traversal Lemma may prove useful in its own right. For example, in quantum adiabatic algorithms, it is often notoriously difficult to understand how a quantum state evolves in time from an easy-to-prepare initial state to some desired final state. The Traversal Lemma gives us a tool for studying the behaviour of such evolutions, playing a crucial role in our analysis here. We remark, however, that in quantum adiabatic evolution, the Hamiltonian itself changes with time, whereas here our Hamiltonian is fixed and we apply local unitary gates to our quantum state.

Organization.

This paper is organized as follows. In Section 2, we state relevant notation, definitions, and useful known results. Section 3 constructs -nets and -pseudo-nets over unitary operators, which are used in Sections 56 and 7 for showing containment of GSCON in QCMA, PSPACE, and NEXP, respectively. Section 4 introduces the notion of -orthogonality and states and proves the Traversal Lemma, which is used in Sections 56, and 7 to show QCMA-hardness, PSPACE-hardness, and NEXP-hardness of GSCON. Section 4.1.1 shows our result regarding tightness of the Traversal Lemma and Section 4.1.2 studies the properties of -orthogonality further. We conclude and state open problems in Section 8.

2 Preliminaries

Notation.

The notation is used to indicate a definition. Given , denotes the computational basis state labeled by . For a vector , define its Euclidean norm as and its infinity norm as . For complex Euclidean space , let , and denote the sets of linear, Hermitian and unitary operators acting on , respectively. We use the following matrix norms: , the spectral norm , and trace norm . The Hilbert-Schmidt or trace inner product between operators and is . The set of natural numbers is , and . Throughout this paper, we treat the local dimension of quantum systems as a constant.

Definitions.

We now formally define the problem studied in this paper. (To ease parsing of the definition, the input parameters are highlighted in maroon online.)

Definition 2.1 (Ground State Connectivity (Gscon)).
  • Input parameters:

    1. -local Hamiltonian acting on qubits with satisfying .

    2. , and integer , such that and .

    3. Polynomial size quantum circuits and generating “starting” and “target” states and (starting from ), respectively, satisfying and .

  • Output:

    1. If there exists a sequence of -local unitaries such that:

      1. (Intermediate states remain in low energy space) For all and intermediate states , one has , and

      2. (Final state close to target state) ,

      then output YES.

    2. If for all -local sequences of unitaries , either:

      1. (Intermediate state obtains high energy) There exists and an intermediate state , such that , or

      2. (Final state far from target state) ,

      then output NO.

A few remarks are in order. First, in the Hamiltonian complexity literature the gap size for energy levels of local Hamiltonians is often taken to be inverse polynomial. Some of our results require this gap to be exponentially small. Allowing to be specified as input thus allows us to precisely formulate such results. Second, the circuits and are assumed to be given in terms of and -qubit unitary gates. Third, all input parameters are specified with rational entries, each using bits of precision.

For completeness, we next give a formal definition of the complexity class QCMA (also known as Merlin-Quantum-Arthur (MQA) [Wat09]).

Definition 2.2 (Qcma).

A promise problem is in QCMA if and only if there exist polynomials , and a polynomial-time uniform family of quantum circuits , where takes as input a string with , a classical proof , and ancilla qubits in state , such that:

  • (Completeness) If , then there exists a proof such that accepts with probability at least .

  • (Soundness) If , then for all proofs , accepts with probability at most .

Useful known results.

We next state known results which prove useful in this paper. The first of these is the Gentle Measurement Lemma of Winter [Win99]; the specific variant we state below is Lemma 9.4.2 from the textbook of Wilde [Wil13].

Lemma 2.3 (Gentle Measurement Lemma [Win99], as stated in Lemma 9.4.2 of [Wil13]).

Let be a density operator and a measurement operator for , such that . Then, .

We next recall Kempe and Regev’s -local circuit-to-Hamiltonian construction [KR03], which maps a given quantum circuit (where each is at most -local) acting on a proof register (register ) and ancilla register (register ) to a -local Hamiltonian acting on , where is a clock register (represented in unary). The precise details of the construction are not necessary for this work; rather, we require only the following key property of . Define the history state for arbitrary proof in register as

(1)

Then, the question of whether accepts is related to the smallest eigenvalue of as follows.

Lemma 2.4 (Kempe and Regev [Kr03]).

Kempe and Regev’s construction maps a quantum circuit to a -local Hamiltonian with parameters and satisfying:

  • If there exists a proof accepted by with probability at least , then achieves

  • If rejects all proofs with probability at least , then the smallest eigenvalue of is at least .

We next discuss the classical reconfiguration problem for Boolean formulae known as -Connectivity (denoted , for short).

Definition 2.5 ().

Given a Boolean -CNF formula and solutions to , does there exist a sequence of strings such that

  1. and , and

  2. for all , the Hamming distance between and is at most , and

  3. for all , is a solution to ?

Theorem 2.6 ([Gkmp06]).

s,t-CONN is PSPACE-complete.

Finally, we state a few useful norm inequalities. For arbitrary complex unit vectors and (see, e.g., Equation 1.33 of Reference [Gha13]):

(2)

For arbitrary (not necessarily normalized) complex vectors, we have:

(3)
Proof.

We use the triangle inequality and the fact that (seen by expanding the definition of ) to obtain:

3 Nets and pseudo-nets over unitary operators

In order to show containment of GSCON in the complexity classes of interest, we require nets with respect to spectral norm over unitary operators. In this section, we give two types of nets: (1) An -net over single qubit unitaries (Lemma 3.1), and (2) an -pseudo-net over unitaries of any dimension (Lemma 3.3). The former is used in Lemma 6.3 (containment in PSPACE) and Lemma 7.6 (containment in NEXP), and consists strictly of unitary operators. The latter is used in Lemma 5.3 (containment in QCMA), and is a relaxation of a net in that it contains non-unitary operators; this relaxed definition, however, allows for a straightforward construction in dimensions greater than two. Note that having an exact net helps make the analysis in the proof of Lemma 6.3 easier, explaining why we use both kinds of nets. We begin with a simple single-qubit -net construction.

Lemma 3.1.

For any , there exists an -net with respect to the spectral norm over of size . Moreover, given the index of any element in the net, can be computed in time .

The proof is given in Appendix A, and relies on a simple characterization of single qubit unitaries. For larger dimensions , however, we are unaware of a similar characterization. Thus, for we construct333It was pointed out to us by an anonymous referee that there is an alternative way to construct an -net over unitary operators with , which can be used in place of our pseudo-net here. Namely, one casts a net over the set of Hermitian operators satisfying , and subsequently exponentiates the items in the net. an -pseudo-net. Intuitively, a pseudo-net over unitary operators contains matrices which are close to, but not necessarily, unitary. However, to aid in its use, it has two important properties: First, we give an efficient “check” procedure such that, for any unitary , there exists a net element satisfying and such that is accepted by . Second, we give an efficient “rounding” procedure such that if net element is accepted by , then rounds to a unitary satisfying .

Definition 3.2 (-pseudo-net).

Let . Then, we call an -pseudo-net over if there exist -time algorithms (for checking) and (for rounding) taking as input such that:

  1. (Checking) , there exists such that accepts and .

  2. (Rounding) , if accepts , then algorithm maps to such that .

We now show that there is a straightforward way to construct an -pseudo-net over for any . The ideas here are based on a standard construction for nets over unitary operators, as used in Reference [PGA11] and detailed further in Lemma 7.13 of Reference [Gha13]; this standard construction is, however, inherently non-explicit. Thus, we adapt it here as necessary to obtain an explicit -pseudo-net.

Lemma 3.3.

For any , there exists a set of size such that:

  1. is an -pseudo-net with respect to spectral norm over unitaries .

  2. Given index , the ’th operator in the net can be computed in time . Here, by ’th operator, we mean with respect to a fixed canonical ordering set by the construction of .

The proof is given in Appendix A.

4 -Orthogonality and the Traversal Lemma

The key technical tool for proving our hardness results is the Traversal Lemma (Lemma 4.2), which we state and prove in this section. In Sections 4.1.1 and 4.1.2, we then show that this lemma is tight up to a polynomial factor and give a further study into the notion of -orthogonality, respectively. We begin by introducing the notions of -orthogonal states and -orthogonal subspaces.

Definition 4.1 (-orthogonal states and subspaces).

For , a pair of states is -orthogonal if for all -qudit unitaries , we have . We call subspaces -orthogonal if any pair of vectors and are -orthogonal.

Let us comment on the structure of -orthogonal states. First, -orthogonality implies orthogonality, but not vice versa. For example, and are -orthogonal and hence orthogonal. In contrast, and are orthogonal but not -orthogonal for any (i.e. simply apply Pauli to qubit to map to ). Similarly, letting and denote the eigenspaces of and , respectively, we have that and are -orthogonal subspaces.

We now prove the Traversal Lemma, which says the following: For any two -orthogonal subspaces and with and , any sequence of -qudit unitaries mapping to must induce an evolution which has “large” overlap with the orthogonal complement of both and at some time step .

Lemma 4.2 (Traversal Lemma).

Let be -orthogonal subspaces. Fix arbitrary states and , and consider a sequence of -qudit unitaries such that

for some . Define and . Then, there exists an such that

Proof.

We give a proof by contradiction. Suppose that for all , the inner products satisfy . Consider the following thought experiment inspired by the quantum Zeno effect. Imagine that after each is applied, we measure using the projective measurement for , and postselect on obtaining outcome . Define the following two sequences:

  • for ,

  • and for .

Note that and are not necessarily normalized.

To set up our contradiction, we first prove by induction on that

(4)

For the base case , we have . Then, since , we know that , and so the Gentle Measurement Lemma [Win99] (Lemma 2.3) yields

(5)

as required. For the inductive case, assume Equation (4) holds for . We prove it holds for . Specifically,

(6)

where the first statement follows from the triangle inequality, the second from the Gentle Measurement Lemma, the fourth from the facts that the Schatten -norms are invariant under isometries and that  [Wat08], and the fifth from the induction hypothesis. This establishes Equality (4).

We thus have

(7)

where we have used Equation (2) to bound

We are now ready to obtain the desired contradiction.

To do so, observe that since , and since and are -orthogonal subspaces, we have that for all , (i.e., if is -dimensional, this is the Zeno effect). Thus, we have , implying that

This contradicts Equation (7), as desired. ∎

4.1 Tightness of the Traversal Lemma and properties of -orthogonality

In the next two subsections, we discuss tightness of the Traversal Lemma and study the properties of -orthogonality further.

4.1.1 On the tightness of the Traversal Lemma

We now ask whether the Traversal Lemma is tight in the following sense: In Lemma 4.2, the lower bound on scales as (for the number of unitaries and for fixed ). This intuitively suggests that one can better “avoid” the subspace projects onto if one uses a longer sequence of local unitaries. Is such behavior possible? Or can the lower bound in Lemma 4.2 be improved to a constant independent of ? In this section, we show that a dependence on in Lemma 4.2 is indeed necessary.

Theorem 4.3.

We assume the notation of Lemma 4.2. Fix any , and consider -orthogonal states and , with . Then, there exists a sequence of -local unitary operations mapping to through intermediate states , each of which satisfy , and where .

The idea behind the proof is based on the following rough analogy: Suppose one wishes to map the point (corresponding to ) in the 2D Euclidean plane to (corresponding to ) via a sequence of moves with the following two restrictions: (1) For each current point , the next move must leave precisely one of or invariant (analogous to -local unitaries acting on a -qubit state), and (2) the Euclidean distance between and the line through and never exceeds (analogous to the overlap with not exceeding ). In other words, we wish to stay close to a diagonal line while making only horizontal and vertical moves. This can be achieved by making a sequence of “small” moves resembling a “staircase”. The smaller the size of each “step” in the staircase, the better we approximate the line, at the expense of requiring more moves (analogous to increasing the number of unitaries, ). Although the idea in this analogy is appealing in its simplicity, applying it to the setting of the Traversal Lemma is non-trivial, requiring a careful selection of -local unitary operations.

Proof of Theorem 4.3.

Our high level approach is as follows. We first give a unitary which is a sequence of two-qubit unitaries mapping to . Given the technique behind ’s construction, one can analogously obtain a unitary which maps to . It follows that . It thus suffices to describe , which is done in two steps. The first step consists of a pair of unitaries which transfer a small amount of amplitude from to ; applying this step repeatedly yields a state “close” to . It is this iterative repetition which causes the overall number of unitaries to scale as . Step 2 then maps precisely onto . We now describe these steps.

Step 1: Iteratively make small steps towards .

Given any state of the form for real , we give a pair of two-qubit unitaries which intuitively transfer a small amount of amplitude from to .

We first apply a two-qubit unitary to qubits and with action and (for real to be specified later), obtaining:

(8)

The overlap of this state with is .

Next, apply a unitary on qubits and with action (omitting normalization for clarity) and , obtaining:

which has overlap with . Setting ensures this process has at most overlap with at each intermediate step.

Let us now analyze the rate at which amplitude is transferred from to by this mapping. To do so, define

which is the new amplitude after the map induced by is applied to input amplitude . Note that for all and when .

We now quantity how much amplitude is transferred from to by this process. Suppose we iteratively apply so long as for some cutoff . Then, the difference satisfies

In other words, each iterative step moves us at least and at most towards our cutoff , implying the number of iterations required to reach the cutoff scales between and . Setting (which lies in when ) ensures that the number of iterations is at most , and sets up the next step of our transformation, which we now discuss.

Step 2: Map an “almost” equal superposition to an equal superposition.

After iterations of Step , we arrive at a state of the form where satisfies

(9)

We seek a sequence of one and two-qubit unitaries which map this state to . To attain this, we instead equivalently give a sequence of unitaries which achieves the reverse mapping.

To begin, we apply a unitary to qubits and with action and for real parameters to be specified later. This maps to

(10)

where . The overlap with at this point is .

Next, define a unitary with action:

Since this unitary is Hermitian, it follows that is mapped to ; hence, applying this unitary to qubits and in Eqn. (10) yields:

This state has overlap with .

Finally, apply a unitary on qubits and which maps to and (the normalized version of) to , obtaining

(11)

It remains to set so as (1) to prevent overlap more than with , i.e. we require , and (2) to ensure that the amplitude on in Eqn. (11) is precisely . Defining implicitly via the equation

clearly satisfies the second of these requirements. Using the upper bound on from Eqn. (9), it is straightforward to verify that the first requirement is also met. ∎

4.1.2 Properties of -orthogonality

We now study the properties of -orthogonality further, and give an intuitive characterization of the notion (Lemma 4.5). We hope this may prove useful in possible independent applications of the concepts introduced in this section.

We begin with the following useful lemma.

Lemma 4.4.

For any , and are -orthogonal if and only if for all subsets of qudits of size at most , we have .

Proof.

Assume first that and are -orthogonal, and consider any with . Then, we have

where the second equality follows since for all linear operators and , and the third equality since  [Wat08] (intuitively, this holds since the optimal rotates the set of left singular vectors of into the set of right singular vectors of ). But now the claim follows, since if and only if . The converse direction proceeds analogously. ∎

Lemma 4.5.

For any , and are -orthogonal if and only if for all subsets of qudits of size at most , we have .

Proof.

Assume first that and are -orthogonal, and consider any with . Let denote the register corresponding to . Then, suppose the Schmidt decompositions of and are and , respectively. Now, by Lemma 4.4, we have

Since and are orthonormal sets, this implies that for any and , either , , or . Thus, letting

we have , or equivalently, since . The converse direction proceeds analogously. ∎

Using Lemma 4.4, we can also easily show the following statement, which studies a notion reminiscent of positive maps versus completely positive maps.

Lemma 4.6.

For any , and are -orthogonal if and only if for any for , and are -orthogonal.

Proof.

Assume first that and are -orthogonal, and consider arbitrary and vectors . Let and be such that . Then we have

where the last equality holds since and are -orthogonal and by Lemma 4.4. Thus, and are -orthogonal. Since and are arbitrary, this direction of the claim holds. The converse statement is trivially true. ∎

5 QCMA-completeness

In this section, we prove the following theorem.

Theorem 5.1.

There exists a polynomial such that GSCON is QCMA-complete for , , , and , where denotes the number of qubits acts on.

Intuitively, this says that GSCON is QCMA-complete when the unitaries are at most -local, the number of unitaries scales polynomially, and the gap scales inverse polynomially. To prove this theorem, we prove QCMA-hardness and containment in QCMA separately. We begin with QCMA-hardness.

5.1 QCMA-hardness

We now show that GSCON is QCMA-hard in the regime described below.

Lemma 5.2.

There exists a polynomial such that GSCON is QCMA-hard for , , , and , where denotes the number of qubits acts on.

Proof.

At a high level, our approach is as follows. Given a QCMA verification circuit , let be the -local Hamiltonian output by Kempe and Regev’s circuit-to-Hamiltonian construction. Then, our aim is to construct another Hamiltonian such that “traversing the ground space of ” forces one to simulate the following protocol — starting with an initial state of all zeroes:

  1. Apply a sequence of -qubit gates to prepare a ground state of .

  2. Flip a first “GO” qubit to initiate a “check” that is indeed a ground state of .

  3. Flip a second and third “GO” qubit to end the “check”.

  4. Uncompute to obtain a target state which is all zeroes, except for the “GO” qubits, which are set to all ones.

Formally, let be an instance of a QCMA problem with verification circuit acting on a classical proof register and ancilla register consisting of and qubits, respectively. Using standard error reduction via parallel repetition, we may assume without loss of generality that