Abstract 1 Introduction 2 Contributions 3 Discussion and open questions References Appendix A Notation and background

Quantum SAT Problems with Finite Sets of Projectors Are Complete for a Plethora of Classes

Ricardo Rivera Cardoso ORCID RCQI, Institute of Physics, Slovak Academy of Sciences, Bratislava, Slovakia Alex Meiburg ORCID Perimeter Institute for Theoretical Physics, Waterloo, Canada
Institute for Quantum Computing, University of Waterloo, Canada
Daniel Nagaj ORCID RCQI, Institute of Physics, Slovak Academy of Sciences, Bratislava, Slovakia
Abstract

Previously, all known variants of the Quantum Satisfiability (QSAT) problem – consisting of determining whether a k-local (k-body) Hamiltonian is frustration-free – could be classified as being either in 𝖯; or complete for 𝖭𝖯, 𝖬𝖠, or 𝖰𝖬𝖠𝟣. Here, we present new qubit variants of this problem that are complete for 𝖡𝖰𝖯𝟣, 𝖼𝗈𝖱𝖯, 𝖰𝖢𝖬𝖠, 𝖯𝖨(𝖼𝗈𝖱𝖯,𝖭𝖯), 𝖯𝖨(𝖡𝖰𝖯𝟣,𝖭𝖯), 𝖯𝖨(𝖡𝖰𝖯𝟣,𝖬𝖠), 𝖲𝗈𝖯𝖴(𝖼𝗈𝖱𝖯,𝖭𝖯), 𝖲𝗈𝖯𝖴(𝖡𝖰𝖯𝟣,𝖭𝖯), and 𝖲𝗈𝖯𝖴(𝖡𝖰𝖯𝟣,𝖬𝖠). Our result implies that a complete classification of quantum constraint satisfaction problems (QCSPs), analogous to Schaefer’s dichotomy theorem for classical CSPs, must either include these 13 classes, or otherwise show that some are equal. Additionally, our result showcases two new types of QSAT problems that can be decided efficiently, as well as the first nontrivial 𝖡𝖰𝖯𝟣-complete problem.

We first construct QSAT problems on qudits that are complete for 𝖡𝖰𝖯1, 𝖼𝗈𝖱𝖯, and 𝖰𝖢𝖬𝖠. These are made by restricting the finite set of Hamiltonians to consist of elements similar to Hinit, Hprop, and Hout, seen in the circuit-to-Hamiltonian transformation. Usually, these are used to demonstrate hardness of QSAT and Local Hamiltonian problems, and so our proofs of hardness are simple. The difficulty lies in ensuring that all Hamiltonians generated with these three elements can be decided in their respective classes. For this, we build our Hamiltonian terms with high-dimensional data and clock qudits, ternary logic, and either monogamy of entanglement or specific clock encodings. We then show how to express these problems in terms of qubits, by proving that any QCSP can be reduced to a qubit problem while maintaining the same complexity – something not believed possible classically. The remaining six problems are obtained by considering “sums” and “products” of some of the QSAT problems mentioned here. Before this work, the QSAT problems generated in this way resulted in complete problems for 𝖯𝖨 and 𝖲𝗈𝖯𝖴 classes that were trivially equal to 𝖭𝖯, 𝖬𝖠, or 𝖰𝖬𝖠1. We thus commence the study of these new and seemingly nontrivial classes.

While [Meiburg, 2021] first sought to prove completeness for 𝖼𝗈𝖱𝖯, 𝖡𝖰𝖯1, and 𝖰𝖢𝖬𝖠, we note that those constructions are flawed. Here, we rework them, provide correct proofs, and obtain improvements on the required qudit dimensionality.

Keywords and phrases:
Quantum complexity theory, quantum satisfiability, circuit-to-Hamiltonian, pairwise union of classes, pairwise intersection of classes
Copyright and License:
[Uncaptioned image] © Ricardo Rivera Cardoso, Alex Meiburg, and Daniel Nagaj; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Quantum complexity theory
Related Version:
Full Version: https://arxiv.org/abs/2506.07244 [14]
Acknowledgements:
We thank Alex Grilo and Dorian Rudolph for helpful discussions, and the authors of Ref. [12] for the inspiration of Figure 8 in the full version of this paper.
Funding:
RRC and DN were supported by projects APVV-22-0570 (DeQHOST) and VEGA No. 2/0164/25 (QUAS). AM was supported by the Natural Sciences and Engineering Research Council of Canada through grant number RGPIN-2019-04198. IQC and the Perimeter Institute are supported in part by the Government of Canada through ISED and the Province of Ontario.
Editor:
Bill Fefferman

1 Introduction

Many of the interesting and puzzling phenomena in many-body physics occurs at the ground state of materials. One way to study quantum systems in this state is through their ground state energy, as this quantity can be used to provide information about physical and chemical properties of the system. It is thus of great interest to calculate or even estimate this quantity. This task is embodied by the k-Local Hamiltonian (k-LH) problem. Specifically, given a k-local (k-body) Hamiltonian – an operator of the form H=ihi where each hi acts on at most k qubits – and two numbers a,b with ba1/poly(n), this problem consists of distinguishing between the cases where H has an eigenvalue less than a or greater than b. Kitaev [30] showed that k-LH with k5 (and later improved to k2 [28]) is unlikely to be decided efficiently with a classical or quantum computer. In complexity theory terms, k-LH with k2 is 𝖰𝖬𝖠-complete.111The class 𝖰𝖬𝖠 can be thought of as the quantum analog of 𝖭𝖯, or more accurately 𝖬𝖠 since the class has probabilistic acceptance and rejection.

The LH problem is considered a “weak” quantum constraint satisfaction problem (QCSP) as states with energy less than a do not necessarily minimize the energy of each hi. For this reason, LH is often compared to MAX-k-SAT instead of the “strong” CSP k-SAT. Due to the immense importance of SAT in classical complexity and other hard sciences, Bravyi [6] defined the Quantum k-SAT (k-QSAT) problem. Given a set of k-local projectors (also referred as clauses or constraints) and a number b, this problem consists of distinguishing between the cases where there exists a state that simultaneously lies in the null space of all projectors, or for all states, the penalty incurred by violations of the constraints is greater than b.222Alternatively, this problem can be defined with local Hamiltonians instead of projectors, in which case, the problem is equivalent to determining whether the Hamiltonian is frustration-free. Bravyi showed that 2-QSAT on qubits is in 𝖯 while k-QSAT with k4 (and later improved to k3 [22]) is 𝖰𝖬𝖠1-complete when using the Clifford+T gate set 𝒢8={H,CNOT,T}.333𝖰𝖬𝖠1 is the one-sided error variation of 𝖰𝖬𝖠 with perfect completeness, i.e. instances for which the answer is “yes” (in this case frustration-free Hamiltonians) are accepted with certainty. The notation 𝒢8 stems from Ref. [4] and denotes the Clifford-cyclotomic gate set of degree of 8. The reason why it is necessary to specify the gate set for classes with perfect completeness is discussed in Section A.2.

Interestingly, these two problems have in common that they are in 𝖯 for a certain k but appear to become much harder for k+1: LH is in 𝖯 for k1 and becomes 𝖰𝖬𝖠-complete for k>1, while QSAT is in 𝖯 for k2 and 𝖰𝖬𝖠1𝒢8-complete for k>2. This is not entirely surprising since the Hamiltonians considered in the problems have no restriction other than their locality, and perhaps the difficulty lies in deciding “unphysical” Hamiltonians. Following this line of thought, others have considered variations of these problems where the hi are drawn from more realistic and relevant sets that satisfy some property or correspond to a physical model. To name a few, these may be stoquastic [7], commuting [9], fermionic [31], bosonic [41], or from models like the Heisenberg [39] and Bose-Hubbard [15]. In addition, one might also consider placing restrictions on the geometry of the problem [33, 23, 2, 26, 36].

In a landmark result, Cubitt and Montanaro [18] showed that any LH problem where the hi are drawn from a finite set of at most 2-local qubit Hermitian matrices can be classified as being either in 𝖯, 𝖭𝖯-complete, 𝖲𝗍𝗈𝗊𝖬𝖠-complete, or 𝖰𝖬𝖠-complete.444𝖲𝗍𝗈𝗊𝖬𝖠 is the class of problems equivalent to estimating the ground state energy of the transverse-field Ising model [8]. As decision problems in the latter three classes are not known to be efficiently solvable in either classical or quantum computers, they showed that the only Hamiltonians of this type for which the LH problem can be solved efficiently are those with only 1-local terms. This is significant, as many relevant Hamiltonians in nature can be approximated by 2-local Hamiltonians of this type (e.g. all those supported on Pauli operators like Heisenberg and Ising spin glass models), and it is then likely that estimating their ground state energy efficiently lies outside of reach. Moreover, their result has led to a much larger repertoire of problems from which to construct reductions and potentially show the complexity of other computational problems.

Prior to our work, all known QSAT problems with finite or infinite sets of local interactions could be classified as being either in 𝖯, 𝖭𝖯-complete, 𝖬𝖠-complete, or 𝖰𝖬𝖠1-complete, but this list is not known to be exhaustive in either case. The fact that QSAT has resisted classification can be attributed to two factors. First, is that since most relevant instances of QSAT can be decided classically (2-QSAT is in 𝖯), there is a lack of interest to search for a classification of QSAT problems with k>2. This is unlike in the LH problem where most relevant instances were hard (2-LH is 𝖰𝖬𝖠-complete), motivating the study of Cubitt and Montanaro. Second, is the fact that QSAT problems are usually complete for classes that are harder to work with as they seem to depend on gate sets. In this work, it is our goal to concretize the implications that such a theorem may have, and hence motivate its study.

1.1 Summary of results

Our main result establishes that the QSAT problem SLCT-QSAT is 𝖡𝖰𝖯1𝒢8-complete. However, as the construction and analysis of this problem is contrived, we first show that the simpler and less optimized version of this problem, LCT-QSAT, is also complete for this class.

Theorem 1.

The problem Linear-Clock-Ternary-QSAT (LCT-QSAT) with 4-local clauses acting on 17-dimensional qudits is 𝖡𝖰𝖯1𝒢8-complete.

An interesting feature of this problem, and one that may be of independent interest, is that this problem makes clever use of the principle of monogamy of entanglement to strongly constrain the structure of input instances, facilitating the task of deciding whether they are frustration-free.555This construction is the most faithful to those considered by Meiburg in Ref. [32]. Unfortunately, this trick comes at a price of high qudit dimensionality. Our main result shows that by relaxing the constraint on the instance’s structure and instead study the instances more closely, we can obtain a similar problem with the same complexity but with reduced qudit dimensionality.

Theorem 2.

The problem Semilinear-Clock-Ternary-QSAT (SLCT-QSAT) with 4-local clauses acting on 6-dimensional qudits is 𝖡𝖰𝖯1𝒢8-complete.

Recently, among many other interesting results, Rudolph [37] demonstrated that 𝖡𝖰𝖯1𝒢2i=𝖡𝖰𝖯1𝒢2j for any i,j. In other words, any problem in 𝖡𝖰𝖯1 using a Clifford-cyclotomic gate set of degree 2i can be perfectly simulated with one of degree 2j for all i,j. For us, this then implies that:

Corollary 3.

The problems LCT-QSAT and SLCT-QSAT are 𝖡𝖰𝖯1-complete with any gate set 𝒢2l with l.

Subsequently, by performing slight modifications to the clauses of SLCT-QSAT, we also obtain 𝖰𝖢𝖬𝖠-complete and 𝖼𝗈𝖱𝖯-complete problems:

Theorem 4.

The problem Witnessed SLCT-QSAT with 4-local clauses acting on 8-dimensional qudits is 𝖰𝖢𝖬𝖠-complete.

Theorem 5.

The problem Classical SLCT-QSAT with 5-local clauses acting on 8-dimensional qudits is 𝖼𝗈𝖱𝖯-complete.

Then, using a similar application of monogamy of entanglement as in LCT-QSAT, we demonstrate that we can reduce any QCSP on qudits to another one on qubits.

Theorem 6 (informal).

Every QCSP 𝒞 on qudits is equivalent in difficulty to some other QCSP 𝒞 on qubits.

Corollary 7.

Together, Theorems 2, 4, 5, and 6 imply:

  1. 1.

    SLCT-QSAT2 is a 𝖡𝖰𝖯1𝒢8-complete problem on qubits with 48-local clauses.

  2. 2.

    Witnessed SLCT-QSAT2 is a 𝖰𝖢𝖬𝖠-complete problem on qubits with 48-local clauses.

  3. 3.

    Classical SLCT-QSAT2 is a 𝖼𝗈𝖱𝖯-complete problem on qubits with 60-local clauses.

We refer to these problems by the same name as before, except that we now add a subindex to represent that the problem refers to the qubit version, e.g. SLCT-QSAT2 is the QSAT problem that results from the reduction of SLCT-QSAT.

Finally, there is a notion of direct product” and direct sum” (Definitions 17 and 18) for both CSPs and QCSPs, which we use to show that there are six new QSAT problems that are complete for classes 𝖯𝖨(A,B) and 𝖲𝗈𝖯𝖴(A,B), where A and B are themselves complexity classes. 𝖯𝖨(A,B) stands for the pairwise intersection of classes (Definition 11), and 𝖲𝗈𝖯𝖴(A,B) for the star of pairwise union of classes (Definition 12). Roughly, these two classes correspond to the sets of problems that can be expressed as the intersection and union (respectively) of a problem in A and a problem in B.666These classes are not to be confused with AB and AB. AB corresponds to the set of problems that are in both A and B, while AB corresponds to those that are in either A or B. We show:

Theorem 8.

Let and denote the direct product and direct sum for quantum constraint satisfaction problems. Pairwise combinations of the four QSAT problems – 3-SAT, Classical SLCT-QSAT2, SLCT-QSAT2, and Stoquastic 6-SAT – yield the following complete problems:

  1. 1.

    Classical SLCT-QSAT2 3-SAT is 𝖯𝖨(𝖼𝗈𝖱𝖯,𝖭𝖯)-complete.

  2. 2.

    Classical SLCT-QSAT2 3-SAT is 𝖲𝗈𝖯𝖴(𝖼𝗈𝖱𝖯,𝖭𝖯)-complete.

  3. 3.

    SLCT-QSAT2 3-SAT is 𝖯𝖨(𝖡𝖰𝖯𝟣𝒢𝟪,𝖭𝖯)-complete.

  4. 4.

    SLCT-QSAT2 3-SAT is 𝖲𝗈𝖯𝖴(𝖡𝖰𝖯𝟣𝒢𝟪,𝖭𝖯)-complete.

  5. 5.

    SLCT-QSAT2 Stoquastic 6-SAT is 𝖯𝖨(𝖡𝖰𝖯𝟣𝒢𝟪,𝖬𝖠)-complete.

  6. 6.

    SLCT-QSAT2 Stoquastic 6-SAT is 𝖲𝗈𝖯𝖴(𝖡𝖰𝖯𝟣𝒢𝟪,𝖬𝖠)-complete.

Finally, given that the QSAT problems in Corollaries 7 and 8 consist of finite sets of projects with 𝒪(1)-local qubit clauses, and similarly 2-SAT, 3-SAT, Stoquastic 6-SAT, and 3-QSAT (which are respectively in 𝖯, 𝖭𝖯-complete, 𝖬𝖠-complete and 𝖰𝖬𝖠1𝒢8-complete), our results imply that:

Corollary 9.

A complete classification theorem for strong QCSPs with 𝒪(1)-local clauses acting on qubits must either include at least 13 classes, or otherwise indicate that some of these are equal.

The relationship between the 13 classes mentioned here is shown in Figure 1.

Figure 1: The classes for which we now have a complete strong QCSP, and their corresponding inclusions. In this work, we show completeness for quantum complexity classes with perfect completeness using the Clifford+T gate set 𝒢8={H,T,CNOT}. Rudolph’s result [37] further strengthens ours by showing that 𝖡𝖰𝖯1𝒢8=𝖡𝖰𝖯1𝒢2l for all l1. We discuss some of the inclusions in this figure in Section 2.6 and Section A.2.

2 Contributions

In this section, we summarize the main ideas and proof techniques related to the results presented in Section 1.1. In particular, we detail the main roadblocks in the construction of each QSAT problem, and how we overcome them. The full proofs of the statements here can be found in the full version of the text [14].

Appendix A covers the notation and background information used here. For the rest of this section, we fix the gate set 𝒢8 and omit the superscript when referring to 𝖡𝖰𝖯1 and 𝖰𝖬𝖠1, except when needed for emphasis.

2.1 BQP1-complete problem

(a)
(b)
(c)
Figure 2: (a) A typical instance that encodes the computation of a 𝖡𝖰𝖯1 circuit ULU1. The satisfiability of the instance can also be decided in 𝖡𝖰𝖯1. (b) Examples of troublesome instances whose satisfiability is not known to be decidable with a 𝖡𝖰𝖯1 algorithm. (c) The above instances recast with the new set of projectors {Πinit,Πprop,U,Πout}. The bold blue arrows represent the Πprop,U clauses which now also indicate the particles should be maximally entangled, and the dotted red arrows those that are connected to undefined logical qudits. With these projectors, their satisfiability can be more easily decided. The left instance is satisfiable due to the undefined clauses, while the one on the right is unsatisfiable, as any potential satisfying state violates monogamy of entanglement. The instance in (a) has the same meaning/satisfiability with either set of projectors.

The goal of the construction is to design a QSAT problem that can encode the computation of any quantum circuit in 𝖡𝖰𝖯1, while keeping all its instances solvable in quantum polynomial-time with perfect completeness and bounded soundness. We define the problem using projectors Πinit, Πprop,U, and Πout similar to Pinit, Pprop,U, and Pout defined in Equation 6.777The projectors Pstart, Pclock, and Pstop associated with the clock encoding remain unchanged and are integrated into the definitions of Πinit, Πprop, and Πout. To see why our projectors must differ from the original ones, consider the QSAT problem built with {Pinit,Pprop,U,Pout,Pstart,Pclock,Pend}. Showing that the problem is 𝖡𝖰𝖯1-hard is straightforward, as we can encode the circuit that computes the answer to a 𝖡𝖰𝖯1 problem in a similar way as that shown in Section A.3. This time however, all data particles in the instance should be initialized, instead of having free particles whose role is to accommodate a witness state. The difficulty lies in demonstrating that every instance generated with a polynomial number of these projectors can also be decided in 𝖡𝖰𝖯1. There is a fundamental and a practical limitation for this:

  • Instances which encode the computation of a 𝖰𝖬𝖠1 problem, e.g. the instance in Figure 4 and the left instance in Figure 2(b), are valid inputs. This is problematic since it is unknown how to decide these instances in 𝖡𝖰𝖯1 (and doing so would show that 𝖡𝖰𝖯1=𝖰𝖬𝖠1).

  • Input instances may form intricate structures complicating the task of deciding if a satisfying state exists, e.g. the right instance in Figure 2(b).

We define the projectors Πinit, Πprop, and Πout to address these two difficulties (see Figure 2(c)). Importantly, these projectors do not significantly alter the proof that the problem is 𝖡𝖰𝖯1-hard and can proceed as mentioned. Now, let us briefly discuss how we overcome both difficulties.

Instances like those in Figure 4, which have a proper structure and uninitialized data particles, are prototypical examples of 𝖰𝖬𝖠 instances. These “free” particles give one the freedom to guess if there exists a state they can be in such that the instance can be satisfied (or equivalently be provided with such a state which we verify). To address this issue, we remove the need to guess a satisfying state by introducing a new undefined basis state |? (making the data particles 3-dimensional), such that setting the free data particles to this state always results in a satisfiable instance. More specifically, we achieve this by defining Πprop,U so that if any data particle in the clause is in state |?, the clause is satisfied without needing to apply the associated unitary.888Although the data particles are 3-dimensional and the unitaries are gates from a set designed to act on qubits, these cause no conflicts as the gates will never act on undefined data particles. Then, for these instances, the satisfying state is given by a truncated version of the history state (without a witness) since the computation is no longer required to elapse past the first Πprop,U clause acting on an undefined state. We say the instance is now “trivially satisfiable” as its structure alone suffices to determine its satisfiability.

To determine the satisfiability of intricate instances, the projectors are now also defined to leverage the principle of monogamy of entanglement. Each clock particle is equipped with two 2-dimensional auxiliary subspaces CA and CB (making them 12-dimensional) and the Πprop,U clauses are then defined to require that the CB subspace of the predecessor clock particle forms a |Φ+ Bell pair with the CA subspace of its successor. Then, if a CA or CB subspace is required to form more than one Bell pair, the principle of monogamy of entanglement states that only one of these clauses can be satisfied, and so the instance is unsatisfiable. Therefore, instances that are not deemed unsatisfiable because of this reason must form one-dimensional chains with a unique “time” direction. Finally, to guarantee that Πinit and Πout only act on the ends of the chain, these make use of a new endpoint particle consisting of a single two-dimensional space EC and require that it also forms a Bell pair with either the CA (for Πinit) or CB (for Πout) subspace of a clock particle. These modifications thus yield a 17-dimensional local Hilbert space: a 3-dimensional data subspace, plus a 2-dimensional endpoint subspace, plus a 12-dimensional clock subspace.

Although these modifications do not get rid off all difficulties, a comprehensive analysis of the resulting instances can be used to demonstrate that a hybrid algorithm can determine the satisfiability status of all input instances. Briefly, the classical part of the algorithm evaluates the structure of the clauses in the instance and concludes whether it is trivially unsatisfiable, trivially satisfiable, or is one requiring the assistance of a quantum subroutine. Trivially unsatisfiable instances are those whose clause arrangement imply one or several clauses cannot be simultaneously satisfied, like those that violate monogamy of entanglement. On the other hand, trivially satisfiable instances are those whose clauses do not create any conflicts but whose structure is simple enough that the satisfying state can be inferred, like those with a proper structure and uninitialized data particles. We show that the only type of instances that are not in either one of these cases, are those like Figure 2(a) which express the computation of a quantum circuit on initialized ancilla qubits. For these instances, the classical algorithm makes use of a quantum subroutine that executes the quantum circuit expressed by the instance, while simultaneously measuring the eigenvalues of relevant projectors. The measurement outcomes indicate whether the instance should be accepted or rejected.

2.2 Reducing the qudit dimensionality

This section argues that even by removing the projectors that demand successive clock (or endpoint) particles must be entangled with each other, the satisfiability of instances remains the same. Specifically, we argue that the propagation rules, the choice of clock encoding, and the requirement to maintain a consistent clock register state at all times suffice to show that any instance in which the clock particles are not arranged linearly and do not point in the same direction is unsatisfiable. Consequently, there is no longer a need for auxiliary subspaces or endpoint particles. Together, these results show that while the use of monogamy of entanglement in the construction does facilitate some proofs, it is not crucial for the construction. Removing these elements reduce the local dimension from 17 down to 6.

The main challenge in this construction stems from the weaker constraints that the Πinit and Πout clauses set instead of the endpoint particles. In summary, instances with more than a single Πinit/Πout pair may now be satisfiable. Part of the proof of this section requires showing that if such sub-instances are potentially satisfiable, they can be further separated into smaller linear instances, each with a single Πinit/Πout pair. Each of these smaller pieces is then satisfied by a history state, while the clauses connecting them together (arranged in any shape) can be satisfied trivially. For this reason, we have used the term semilinear in the name of the resulting problem.

2.3 QCMA-complete problem

(a)
(b)
Figure 3: (a) Toy example of an input “quantum” instance with a TACC of length L=4, acting on four logical qudits and two witness qudits. Although not illustrated, the Πprop clauses are assumed to have unitaries U1,,U4 which act only on the logical qudits of the instance. These unitaries define a circuit U=U4U3U2U1. (b) Quantum circuit representing the instance on the left.

The construction from Section 2.2 can be modified to generate a 𝖰𝖢𝖬𝖠1𝒢8-complete problem. Moreover, since 𝖰𝖢𝖬𝖠1𝒢8=𝖰𝖢𝖬𝖠 [27], this results in a 𝖰𝖢𝖬𝖠-complete problem. Although there are already many problems known to be complete for this class [19, 42, 21, 24, 40], none of them are strong QCSPs.999While Ref. [40] also defines a 𝖰𝖢𝖬𝖠-complete QSAT problem, it requires additional promise conditions.

In Section 2.1, we argued that the unconstrained or “free” logical qudits of an instance allowed one to guess what state of these qudits (the witness state) might satisfy the instance. This freedom made the problem more difficult and thus not likely contained in 𝖡𝖰𝖯1. For this reason, we introduced the undefined state |?, which simplified these instances and made them decidable in 𝖡𝖰𝖯1. In this construction, we seek to construct a problem that sits in between these two classes so it is 𝖰𝖢𝖬𝖠-complete. To accomplish this, we desire to have “free” logical qudits to accommodate a witness state that helps verify whether the instance is satisfiable, but have some sort of constraint to demand that the state is classical.101010We continue using the undefined state for logical qudits whose initial state is not constrained so the difficulty of the problem does not become 𝖰𝖬𝖠.

In practice, creating these constraints is challenging since any superposition of two satisfying states will also satisfy the clause. Instead, we set the constraints such that if there exists a quantum witness state that is part of a satisfying state, there is also a classical witness state. Loosely, we accomplish this by defining new witness qudits and create a new constraint Π𝑖𝑛𝑖𝑡|00,11 that connects a witness qudit with a logical one, and require that they are both either |00, |11, or in a superposition of the two.111111The local Hilbert space is then 8-dimensional, as it composed of a 3-dimensional data subspace, a 3-dimensional clock subspace, and a 2-dimensional witness subspace. In this way, the two qudits are partially “free” as there is some freedom to their state, yet posses some desired structure. Importantly, we ensure that the witness qudits do not form part of the computation after this initial point.

To see why this leads to the desired effect, consider the toy instance of Figure 3 and suppose there exists a state |ψwit of the four “free” qudits that leads to a satisfying state. Observe that to satisfy the Π𝑖𝑛𝑖𝑡|00,11 clauses, this state must be of the form |ψwit=(α00|0000+α01|0011+α10|1100+α11|1111)L1,W1,L2,W2 with b{0,1}2|αb|2=1, which we can rewrite in a more convenient form as |ψwit=b{0,1}2αb|bL|bW. Then, a state that satisfies all clauses of the instance is the history state

|ψhist =15t=04[UtU0|00|ψwit]|ddtatrr4t (1)
=15t=04b{0,1}2αb|ξbt|bW|ddtatrr4t,

where |ξbt:=UtU0|00|bL. Now, let us argue that there is also a classical witness that leads to a satisfying history state. First, observe that any basis state |bL|bW with |αb|>0 from the decomposition of the witness satisfies the Π𝑖𝑛𝑖𝑡|00,11 clauses. Consequently, the history state above but with initial state |00|bL|bW satisfies the Π𝑖𝑛𝑖𝑡|0, Π𝑖𝑛𝑖𝑡|00,11, and Πprop clauses of the instance. Finally, to show that this state also satisfies the Πout clause, recall that this clause is satisfied if at time t=4, the probability that the second qubit yields outcome “1” when measured is 1. As shown in Equation 3, this probability can be written as

Pr(outcome 1)=b,b{0,1}2αbαbξb4|b|Π(1)|ξb4|b=b{0,1}2|αb|2ξb4|Π(1)|ξb4

where Π(1):=|11|2Irest, and in the last equality we observed that b|b=δb,b. Then, by the assumption that the instance is satisfiable, it must be that ξb4|Π(1)|ξb4=1 for all basis states |b with |αb|>0. This can also be understood as the probability that at the end of the circuit, the second qubit yields outcome “1” when the witness is the basis state |b|b. Therefore, the history state of Equation 1 with classical witness |ψwit=|bL|bW also satisfies all clauses of the instance.

The remaining parts of the proof require showing that all new possible qudit connections with new Π𝑖𝑛𝑖𝑡|00,11 clause can still be handled, as well as demonstrate perfect completeness and bounded soundness of the hybrid algorithm. For the latter, the majority of the arguments from the 𝖡𝖰𝖯1 construction also directly apply here.

2.4 coRP-complete problem

In Section 2.1, we mentioned that the satisfiability of some instances is decided through a quantum circuit. In particular, this circuit was used to verify the satisfiability of the simultaneous Πprop clauses and final Πout clauses. For the latter, the circuit executed the quantum circuit UTU1 on input |0q, measured some of the qubits, and accepted or rejected depending on the measurement outcomes. Intuitively, to generate the 𝖼𝗈𝖱𝖯-complete problem, we would like to replace the universal quantum circuit by a universal classical reversible circuit R=RTR1 (reversibility is needed since the best potentially satisfying state is still a quantum history state) and introduce randomness into the instance by initializing p ancilla qubits to |+. Then, for these new sub-instances, we could analogously verify the Πout clauses by sampling a bitstring b{0,1}p, evaluating the circuit R on input (0q,b) and deciding on its satisfiability based on the final state of the bits. While this idea is close to the actual construction, for reasons mentioned in the full version of the text, it is not sufficient to decide all instances.

For the construction to work, we also incorporate elements of the 𝖰𝖢𝖬𝖠 problem from the previous section. Namely, we modify the Π𝑖𝑛𝑖𝑡|00,11 clause so it initializes both a witness (now referred to as auxiliary qudit as we remove the freedom) and a logical qudit to the maximally entangled state |Φ+. This new clause is denoted Π𝑖𝑛𝑖𝑡|Φ+.

Again using the toy example of Figure 3 (replacing the Π𝑖𝑛𝑖𝑡|00,11 clauses by Π𝑖𝑛𝑖𝑡|Φ+ clauses and the unitaries Ui by reversible classical gates Ri), let us illustrate how this construction allows us to verify the satisfiability of Πout clauses. If the instance is satisfiable, the satisfying state must be the history state

|ψhist =15t=04[RtR0|00|Φ+2]|ddtatrr4t
=15t=04b{0,1}212|ξbt|bAux|ddtatrr4t,

where in the second line we observed that |Φ+p=2p2b{0,1}p|bL|bAux for any p, and defined |ξbt:=RtR1|00|bL. The Πout clause is satisfied if at time t=4, the probability that the second qubit yields outcome “1” when measured is 1. This probability is given by

Pr(outcome 1)=14b,b{0,1}2ξb4|b|Π(1)|ξb4|b=14b{0,1}2ξb4|Π(1)|ξb4,

from where it is evident that if the instance is satisfiable, ξb4|Π(1)|ξb4=1 for all b{0,1}2. Hence, it is possible to verify the Πout clause by sampling one of the strings b, running circuit R on input (02,b), and measuring the state of the second qubit.

Another important consideration is that the classical reversible gate set must be chosen with care. Although not covered in this version of the paper, we usually desire that 𝒢 is a gate set such that all gates in the set change the basis states upon application, and so V(Πi) of Equation 2 can be implemented perfectly with gates from this set. Here, only the first property is relevant. We choose 𝒢={X,(XXX)Toffoli}, which clearly satisfies this property and is also a universal gate set for reversible classical computation. As a consequence, the QSAT problem of this section has 5-local clauses since the Πprop clauses may use a Toffoli. This is the best locality we can achieve as it is also well known that any universal gate set for reversible quantum computation must include a 3-bit gate.

2.5 Universality of qubits for QCSPs

In previous sections, we showed that there are QSAT problems acting on qudits that are complete 𝖡𝖰𝖯1𝒢8, 𝖰𝖢𝖬𝖠, and 𝖼𝗈𝖱𝖯. Here, we refine these statements and show that there are QSAT problems on qubits (albeit with higher locality) that are also complete for these classes. To achieve this, we show that any QCSP on qudits can be reduced to another QSAT problem on qubits using little computational power. We note that this section, apart from some changes in the exposition, stems directly from Ref. [32].

At first glance, this statement may seem trivial as operations on qubits are universal for quantum computation, i.e. we can emulate a d-qudit with a log2(d) qubits and carry out unitaries on those qubits. For our QSAT problems, it is true that any instance retains its satisfiability status when expressed in terms of qubits. However, it is not clear if all input instances generated with these new qubit clauses are contained within this class. For a successful reduction, we must have both.

For an even more explicit example, let us first represent the basis clock states using qubits as: |r:=|00, |a:=|01, and |d:=|10. The Πstart=|rr| clause (defined exactly as Pinit in Equation 7) can now be written as Πstart=|0000|+|1111|, where the last term is to prevent the fourth basis state |11, which did not exist before. The clause (|0000|+|1111|)1,2+(|0000|+|1111|)2,3 acting on three qubits is now valid and is satisfied by the state |010213. This state, however, presents some ambiguity: either we have |r on qubits 1 and 2, or |a on qubits 2 and 3. In general, decomposing all clauses into qubits and considering all input instances that may occur adds a significant level of complexity to the problem, making it difficult to determine if it remains in the same class. Moreover, we remark that this is not only particular to our QSAT problems, but in fact applies to all CSPs and QCSPs defined on qudits or non-Boolean variables! In general, the issue is that we cannot ensure that the new qubit clauses are applied to qubits in a consistent fashion based on its parent qudit problem. For example, a qubit clause might treat a particular qubit as “qubit 1” of a previous d-qudit, while another clause might refer to the same qubit as “qubit 2”. Moreover, the qubit clauses could also “mix and match”, combining “qubit 1” from one previous d-qudit with “qubit 2” from another d-qudit (as in the example with Πstart). Overall, these lead to constraints that were unrealizable in the parent qudit problem.

Our main result of this section shows that with a more clever reduction than directly decomposing a d-qudit into log2(d) qubits, we can guarantee that a satisfiable/unsatisfiable instance on qubits maps to one on qudits with the same satisfiability status. This is something that is not known to be possible classically! More formally, we show that

Theorem 10 (Theorem 6; formal).

For any QCSP 𝒞 on d-qudits, there is another QCSP 𝒞 on qubits, and 𝖠𝖢0 circuits f and g, such that f reduces 𝒞 to 𝒞, and g reduces 𝒞 to 𝒞. If 𝒞 is k-local, then 𝒞 can be chosen to be 42log2(log2(d))k local (that is, O(log(d)) times larger.)

The main idea behind the proof is that in the quantum world, we can fix the issues mentioned above by again using monogamy of entanglement to bind together our constituent qubits into ordered, entangled larger systems. Ultimately, each clause in the resulting qubit problem incorporates new projectors that force a particular ordering of qubits, and any two clauses that try to “mix and match”, or use the same set of qubits but with different ordering, are necessarily frustrated.

If in Theorem 10 we do not require the reductions to be in 𝖠𝖢0, and instead allow 𝖯-reductions, a locality of 4log2(d)k suffices. This is used in Corollary 7.

2.6 Direct sum and direct product problems

There is a notion of direct sum (denoted by “”) and direct product (denoted by “”) on CSPs and QCSPs that allow us to define the remaining six complete problems. To be clear, these are operations on languages themselves, not on instances. For example, we can talk about the languages 3-Colorable4-SAT and 3-Colorable4-SAT. Although this notion appears to be quite natural, we were unable to find many sources discussing such ideas – possibly because the classical theory is not as exciting, for reasons we also discuss. The relevant task here is to demonstrate that sum and product QCSPs inherit completeness properties from their constituents. In this way, we are able to construct QCSPs that are complete for 𝖯𝖨 and 𝖲𝗈𝖯𝖴 classes, defined as follows.

Definition 11 (Pairwise intersection of classes).

If 𝒞1 and 𝒞2 are two complexity classes (any sets of languages), then 𝖯𝖨(𝒞1,𝒞2) is the class that denotes the pairwise intersection of 𝒞1 and 𝒞2. In other words, it is the class of languages that can be written as the intersection, i.e. the logical AND, of a language in 𝒞1 and a language in 𝒞2.

Definition 12 (Star of pairwise unions of classes).

If 𝒞1 and 𝒞2 are two complexity classes, then their star of pairwise unions, denoted 𝖲𝗈𝖯𝖴(𝒞1,𝒞2), is a complexity class defined as follows: for each language L1𝒞1 and L2𝒞2, let d be a fresh symbol that is not in the alphabet of L1 or L2. Then, the language (dL1|dL2) is in 𝖲𝗈𝖯𝖴(𝒞1,𝒞2). 𝖲𝗈𝖯𝖴(𝒞1,𝒞2) is the closure of all such languages under 𝖫 (logspace reductions).

Definition 12 merits a brief explanation. For a pair of languages L1 and L2, what do the strings in the language L:=(dL1|dL2) look like? Given an input string like d010011d101101d101001, it will belong to L if and only if each of the three bitstrings {010011,101101,101001} belongs to either L1 or L2. If C is a complexity class powerful enough to break apart the individual bitstrings from the d-delimited string, as well decide both L1 and L2, then 𝖲𝗈𝖯𝖴(𝒞1,𝒞2)C.

We begin discussing that there are CSPs that are complete for these classes, and then extend this to the quantum setting since the latter follows almost identically.

2.6.1 Direct product of constraint satisfaction problems

To begin, it is useful to recall the precise definition of a CSP. A constraint satisfaction problem is a triple (V,D,C), where V={v1,,vn} is a finite set of variables, each taking a value from the domain D. If the domain is D={0,1}, then we have a Boolean CSP, and can be generalized to dits if D is instead D={0,,d}. C is a set of constraints, where each constraint cC restricts the values that a subset of the variables may take.

Now, let L1 and L2 be two CSPs with domains D1 and D2, and allowed constraints C1 and C2, respectively.

Definition 13 (Direct product of CSPs).

Given the CSPs L1 and L2, their direct product L1L2 is a CSP whose domain is the Cartesian product D1×D2. Each constraint ciC1 (resp. C2) of locality k leads to a constraint ci in L1L2, also of locality k, as follows. A tuple (v1,v2,,vk)(D1×D2)k, where each entry vi=(vi,1,vi,2), belongs to ci if the tuple (vi,1,,vk,1) belongs to ci. Each constraint in L1L2 arises this way from a constraint in L1 or L2.

The goal of this subsection is to show that when one CSP is complete for a complexity class A, and another is complete for a class B, the product problem is complete for the complexity class 𝖯𝖨(A,B). Formally,

Theorem 14 (Completeness of direct products for 𝖯𝖨).

Let M be a set of functions closed under composition with local functions, and closed under concatenations (i.e. if some f,g:Σ1Σ2 are each in M, then h:xf(x)g(x) is as well). Let L1 be a CSP complete under M-reductions for a class 𝒞1, and likewise L2 be complete for 𝒞2. Assume that each of 𝒞1 and 𝒞2 are closed under reductions by local functions, closed under intersections, and contain the language All of all strings, Σ. Then, the direct product L1L2 is complete under M-reductions for 𝖯𝖨(𝒞1,𝒞2).

The assumptions in this theorem are mild and satisfied even for AC0-reductions and most complexity classes. In other words, this theorem essentially states that if we have CSPs complete for “reasonable” classes 𝒞1 and 𝒞2, the product CSP is complete for 𝖯𝖨(𝒞1,𝒞2).

2.6.2 Direct sum of constraint satisfaction problems

If direct products let us express (informally) a “two-input logical AND” of two CSPs, then direct sums let us express “unbounded-fanin AND of fanin-2 ORs”.

Definition 15 (Direct sum of CSPs).

Given the CSPs L1 and L2, their direct sum L1L2 is a CSP whose domain is the disjoint union D1ΓD2. Each constraint in L1L2 is either of the form ci(D2k), where ciC1 is a constraint of locality k; or it is ci(D1k) for some ciC2.

To better understand this definition, consider an instance of L1L2 with a single connected component, and assume that it is satisfiable.121212A connected component of a CSP is a connected component in the graph for that CSP, where the vertices are variables, and there is an edge between variables if they share a constraint. The definition of the problem and this assumption imply that any satisfying state must either have all variables set to values from D1, or all of them must be from D2. Then, for a general instance of L1L2, solving the problem amounts to identifying all of the connected components, and for each one determine whether it can be satisfied entirely from values of D1 or D2. The instance is satisfiable iff all components are as well.

One might expect that, by analogy with the direct product, the sum of CSPs should then be complete for the pairwise union of two classes, 𝖯𝖴(A,B). This would be true if we only had to worry about problems that formed a single connected component, which is not the case. This is why we must define the “star of pairwise unions” as in Definition 12. The goal of this section is to demonstrate this fact formally.

Theorem 16 (Completeness of direct sums for 𝖲𝗈𝖯𝖴).

Let be M a set of functions closed under composition with logspace-computable functions (such as the set of logspace functions themselves, 𝖥𝖫). Let L1 be a CSP complete under M-reductions for a class 𝒞1, and likewise L2 be M-complete for 𝒞2. Assume that each of 𝒞1 and 𝒞2 are closed under M-reductions, and contain the language None of no strings, . Then, the direct sum L1L2 is complete under M-reductions for 𝖲𝗈𝖯𝖴(𝒞1,𝒞2).

2.6.3 Quantum sums and products

The constructions above transfer in a very natural way to the quantum setting. Now, instead of domains that are a Cartesian product or disjoint union, the Hilbert spaces are a tensor product or direct sum. The clauses are accordingly built as tensor products and direct sums.

Definition 17 (Direct product of QCSPs).

Given the QCSPs L1 and L2, their direct product L1L2 is a QCSP whose domain is the tensor product Hilbert space D1D2. Each operator Hi in L1 leads to an operator HiI, a tensor product with the identity, and likewise for L2.

Definition 18 (Direct sum of QCSPs).

Given the QCSPs L1 and L2, their direct sum L1ΓL2 is a QCSP whose domain is the direct sum Hilbert space D1D2. Each operator Hi in L1 leads to an operator Hi0, a direct sum with the 0 operator, requiring that a frustration-free state lies in the null space of Hi or the right half of the direct sum (or a linear combination). Likewise for operators in L2.

These have the same essential properties as the direct product and sum for classical CSPs, where we can produce product and sum instances that are satisfiable iff both (resp. either) of the original instances are satisfiable.

Given the discussion above on languages and strings of symbols, one might think that we must talk about quantum states and concatenations of strings of qubits. This is not the case. The strings of symbols are just the encoding of the constraints, which are classical data even for a QCSP. The only quantum-specific requirements involve checking that tensor products or embeddings of satisfying states yield another satisfying state; and the appropriate converse properties. These follow directly from the definition of tensor products and direct sums.

2.6.4 Basic class properties

Here, we state some basic properties of general 𝖯𝖨(A,B) and 𝖲𝗈𝖯𝖴(A,B) classes.

Lemma 19.

If the class B includes the language All of all strings, then A𝖯𝖨(A,B). Similarly, if B includes the language None of no strings, then A𝖲𝗈𝖯𝖴(A,B).

Lemma 20.

𝖯𝖨 and 𝖲𝗈𝖯𝖴 respect the inclusion order of complexity classes. That is, AC and BD implies 𝖯𝖨(A,B)𝖯𝖨(C,D) and 𝖲𝗈𝖯𝖴(A,B)𝖲𝗈𝖯𝖴(C,D).

𝖲𝗈𝖯𝖴 generally leads to a more powerful class than 𝖯𝖨, that is:

Lemma 21.

If classes A and B are closed under reductions by local functions, then 𝖯𝖨(A,B)𝖲𝗈𝖯𝖴(A,B).

This is apparent from the definition of these classes since 𝖲𝗈𝖯𝖴 is also required to compute the AND of multiple inputs. It is also true that 𝖯𝖨 and 𝖲𝗈𝖯𝖴 do not increase the power of classes by combining a class A with something weaker. Formally:

Lemma 22.

If A is closed under intersection, and BA, then 𝖯𝖨(A,B)A. Moreover, if A is closed under logspace reductions, unions, and delimited concatenation, then 𝖲𝗈𝖯𝖴(A,B)A.

2.7 New complete problems

As mentioned previously, while the notion of product and sum of constraint problems seems natural, classical constraint problems do not seem to offer such a rich theory. This is due to the fact that most classes with complete CSPs are contained within each other. Indeed, Allender et al.’s refinement of Schaefer’s dichotomy theorem states that all Boolean CSPs are either in 𝖼𝗈-𝖭𝖫𝖮𝖦𝖳𝖨𝖬𝖤; or are complete for 𝖫, 𝖭𝖫, 𝖫, 𝖯 or 𝖭𝖯 under AC0 reductions [3]. With the exception of 𝖭𝖫 and 𝖫, all possible pairs from this list have an obvious containment relation, so the only nontrivial consequence would be that there exists a CSP, on a domain of size four, that is 𝖯𝖨(𝖫,𝖭𝖫)-complete under AC0 reductions. However, under the more common P-reductions, the complexity of these problems becomes either in 𝖯 or 𝖭𝖯-complete.131313The same is true for CSPs defined on qudits [43]. Then, since 𝖯𝖭𝖯 and these classes meet all properties discussed in Lemma 22, it follows that products or sums of these problems result in complexity classes that are trivially equal to 𝖭𝖯. For example, 2-SAT 3-SAT and 2-SAT 3-SAT are complete problems for 𝖯𝖨(𝖯,𝖭𝖯) and 𝖲𝗈𝖯𝖴(𝖯,𝖭𝖯), but these classes are trivially equal to 𝖭𝖯.

This is no longer the case in this work. The seven classes we have discussed so far which have complete CSPs are 𝖯, 𝖼𝗈𝖱𝖯, 𝖡𝖰𝖯1, 𝖭𝖯, 𝖰𝖢𝖬𝖠, and 𝖰𝖬𝖠1. Importantly, these all have the closure properties discussed in this section so far: union, intersection, logspace reductions, and delimited concatenation; and they all include the trivial problems ALL and NONE. Among these classes, most pairs {A,B} have AB, in which case 𝖯𝖨(A,B)=𝖲𝗈𝖯𝖴(A,B)=B. However, there are three pairs that are not known to contain each other, these are: 𝖼𝗈𝖱𝖯?𝖭𝖯, 𝖡𝖰𝖯1?𝖭𝖯, and 𝖡𝖰𝖯1?𝖬𝖠. Each of these pairs leads to two new classes 𝖯𝖨(A,B) and 𝖲𝗈𝖯𝖴(A,B), that are not obviously equal to some other known class. Together, we obtain six more complexity classes with complete QCSPs.

2.7.1 Relations to other classes

Notably, the pair 𝖼𝗈𝖱𝖯 and 𝖭𝖯 involves only classical classes, and accordingly there is more theory already developed around them.

From the lemmas stated earlier in this section, one can show that 𝖭𝖯𝖯𝖨(𝖼𝗈𝖱𝖯,𝖭𝖯)𝖲𝗈𝖯𝖴(𝖼𝗈𝖱𝖯,𝖭𝖯)𝖬𝖠. In addition to this, we can relate 𝖯𝖨(𝖼𝗈𝖱𝖯,𝖭𝖯) to the class 𝖣𝖯:=𝖯𝖨(𝖭𝖯,𝖼𝗈𝖭𝖯) studied in Ref. [34]. This class forms the second layer of the boolean hierarchy 𝖡𝖧, i.e. 𝖣𝖯=𝖡𝖧2 [13]. Since 𝖼𝗈𝖱𝖯𝖼𝗈𝖭𝖯, Lemma 20 tells us that 𝖯𝖨(𝖼𝗈𝖱𝖯,𝖭𝖯)𝖣𝖯. On the other hand, 𝖲𝗈𝖯𝖴(𝖼𝗈𝖱𝖯,𝖭𝖯) does not obviously lie in the Boolean hierarchy. If the class was a simple pairwise union (instead of the “star of pairwise unions”), it would lie in 𝖡𝖧3 – the pairwise union of 𝖣𝖯 and 𝖭𝖯. However, it seems unlikely that 𝖲𝗈𝖯𝖴(𝖼𝗈𝖱𝖯,𝖭𝖯) falls within this class, as doing so would require showing that one could condense the long list of checks required to decide a SoPU problem down to only two queries. In this line of thought, we know that queries to an 𝖭𝖯 oracle do not need to depend on each other adaptively, so 𝖲𝗈𝖯𝖴(𝖼𝗈𝖱𝖯,𝖭𝖯) is contained in 𝖯||𝖭𝖯=𝖯𝖭𝖯[log], studied in Refs. [11, 25].141414𝖯||𝖭𝖯 is the class of problems that can be solved by a 𝖯 machine with polynomially many nonadaptive 𝖭𝖯 queries, or alternatively, logarithmically many adaptive queries.

These classes are also related to two interesting collapse statements. First, observe that if 𝖯=𝖱𝖯 (derandomization), then 𝖼𝗈𝖱𝖯=𝖯𝖭𝖯 and so 𝖭𝖯𝖯𝖨(𝖼𝗈𝖱𝖯,𝖭𝖯)𝖲𝗈𝖯𝖴(𝖼𝗈𝖱𝖯,𝖭𝖯)=𝖲𝗈𝖯𝖴(𝖭𝖯,𝖭𝖯)=𝖭𝖯. Moreover, an even weaker version of derandomization where 𝖭𝖯=𝖬𝖠 would also lead to a collapse. Here, since 𝖼𝗈𝖱𝖯𝖬𝖠, we have 𝖭𝖯𝖯𝖨(𝖼𝗈𝖱𝖯,𝖭𝖯)𝖲𝗈𝖯𝖴(𝖼𝗈𝖱𝖯,𝖭𝖯)𝖲𝗈𝖯𝖴(𝖬𝖠,𝖭𝖯)=𝖲𝗈𝖯𝖴(𝖭𝖯,𝖭𝖯)=𝖭𝖯. Second, we see that if 𝖭𝖯=𝖼𝗈𝖭𝖯 (concise refutations), then 𝖼𝗈𝖱𝖯𝖼𝗈𝖭𝖯=𝖭𝖯.

For the 𝖯𝖨 and 𝖲𝗈𝖯𝖴 classes that involve 𝖡𝖰𝖯1, 𝖭𝖯, or 𝖬𝖠, it seems difficult to state other inclusions, besides the fact that they lie above 𝖡𝖰𝖯1 and below 𝖰𝖢𝖬𝖠.

3 Discussion and open questions

Perhaps the most interesting points of discussion are the implications of Corollary 9. In the latter case, if a complete classification theorem for QSAT problems shows that there are fewer than 13 classes, this would present exciting implications as equalities between some of these classes tackle many interesting and open questions (see Figure 1). This is true even for adjacent classes. For instance, 𝖯=𝖼𝗈𝖱𝖯 would imply that probabilistic algorithms with perfect completeness can be derandomized, and 𝖰𝖢𝖬𝖠=𝖰𝖬𝖠1 would imply that any quantum-verifiable problem (with perfect completeness) could be verified using a classical witness state. Even for the 𝖯𝖨 and 𝖲𝗈𝖯𝖴 classes defined here, we have that if 𝖯𝖨(A,B)=A, then BA. As mentioned in Section 2.7, it is expected through derandomization conjectures that some of these classes are in fact equal to each other. Even if this classification theorem proves any of these conjectures, it would be a great result since such proofs have eluded us for many decades. In the former case of Corollary 9, a classification showing that there are more than 13 classes would be a stark contrast with classical CSPs, which can be completely classified as being either in 𝖯 or 𝖭𝖯-complete [38, 43]. This would highlight the more rich and complex panorama of strong QCSPs, and establish a larger repertoire of problems from which to construct reductions and potentially describe the complexity of other problems.

This last point also raises the question whether there could be other classes with complete QSAT problems. Considering those corresponding to polynomial-time computation and verification, we think that this is unlikely. For example, we have not mentioned complete QCSPs for 𝖡𝖯𝖯, 𝖡𝖰𝖯, or 𝖰𝖬𝖠. Since 𝖼𝗈𝖱𝖯𝖡𝖯𝖯, 𝖡𝖰𝖯1𝖡𝖰𝖯, and 𝖰𝖬𝖠1𝖰𝖬𝖠, there are clearly strong QCSPs in these classes. However, the challenge lies in proving their hardness: as shown in Section A.3, these proofs usually require encoding a probabilistic circuit into an instance of this problem. As is also shown there, perfect completeness is critical for the construction, and thus does not work for a circuit with two-sided error. Adressing this would require a different technique.151515Another technique is to reduce an already known hard problem into an instance of the target problem. For the LH problem, this is done via perturbation theory gadgets [28, 39, 18]. However, these gadgets rely on approximations and hence do not preserve perfect completeness. A positive resolution could arise if these classes admit a scheme that boosts their acceptance probabilities to 1. Jordan et al. [27] showed that this was possible for 𝖰𝖢𝖬𝖠 (demonstrating that 𝖰𝖢𝖬𝖠=𝖰𝖢𝖬𝖠1), but whether this is possible for 𝖡𝖯𝖯, 𝖡𝖰𝖯, or 𝖰𝖬𝖠 remains an open question. Another set of classes we have not considered, are those with no error. Little is known about these classes as they appear to be extremely difficult to work with since the perfect soundness requirement implies that no incorrect instance is ever accepted. Besides classes related to polynomial-time computation and verification, there could be other classes with complete QCSPs. After all, the complexity class landscape is vast.

In Theorems 2 and 5, we describe two new types of QSAT problems that can be solved efficiently with a quantum or probabilistic classical computer. Unfortunately, the projectors used in these problems are artifacts built to achieve these results and do not immediately correspond to QSAT problems of interest, even in the qubit case. Recent developments in the fields of quantum chemistry [5], high-energy physics [35] and nuclear physics [10, 16, 17] have shown that 3- or 4-local Hamiltonians are sometimes necessary to explain emergent physics. The QSAT problems for these Hamiltonians are not immediately tractable as k3, so it would be exciting to determine if these problems, or others, fall within these complexity classes. We hope that having demonstrated that such problems exist, our results inspire others to search for more relevant cases.

Finally, Theorem 8 adds an additional six classes to the set of classes with strong QCSP complete problems. Beyond the inclusions shown in Figure 1, little is known about them. It would thus be interesting to investigate how these classes relate to others, and which other problems fall within them.

References

  • [1] Scott Aaronson. On perfect completeness for QMA. Quantum Inf. Comput., 9(1&2):81–89, 2009. doi:10.26421/QIC9.1-2-5.
  • [2] Dorit Aharonov, Oded Kenneth, and Itamar Vigdorovich. On the Complexity of Two Dimensional Commuting Local Hamiltonians. In 13th Conference on the Theory of Quantum Computation, Communication and Cryptography (TQC 2018), volume 111 of Leibniz International Proceedings in Informatics (LIPIcs), pages 2:1–2:21, Dagstuhl, Germany, 2018. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.TQC.2018.2.
  • [3] Eric Allender, Michael Bauland, Neil Immerman, Henning Schnoor, and Heribert Vollmer. The complexity of satisfiability problems: Refining schaefer’s theorem. Journal of Computer and System Sciences, 75(4):245–254, June 2009. doi:10.1016/j.jcss.2008.11.001.
  • [4] Matthew Amy, Andrew N. Glaudell, Shaun Kelso, William Maxwell, Samuel S. Mendelson, and Neil J. Ross. Exact synthesis of multiqubit clifford-cyclotomic circuits. In Reversible Computation - 16th International Conference, RC 2024, Toruń, Poland, July 4-5, 2024, Proceedings, volume 14680 of Lecture Notes in Computer Science, pages 238–245. Springer, 2024. doi:10.1007/978-3-031-62076-8_15.
  • [5] Alberto Baiardi, Michał Lesiuk, and Markus Reiher. Explicitly correlated electronic structure calculations with transcorrelated matrix product operators. Journal of Chemical Theory and Computation, 18(7):4203–4217, 2022. doi:10.1021/acs.jctc.2c00167.
  • [6] Sergey Bravyi. Efficient algorithm for a quantum analogue of 2-sat, 2006. arXiv:quant-ph/0602108.
  • [7] Sergey Bravyi, Arvid J. Bessen, and Barbara M. Terhal. Merlin-arthur games and stoquastic complexity, 2006. arXiv:quant-ph/0611021.
  • [8] Sergey Bravyi and Matthew Hastings. On complexity of the quantum ising model. Communications in Mathematical Physics, 349(1):1–45, 2017. doi:10.1007/s00220-016-2787-4.
  • [9] Sergey Bravyi and Mikhail Vyalyi. Commutative version of the local hamiltonian problem and common eigenspace problem. Quantum Info. Comp., 5:187–215, May 2005. doi:10.26421/QIC5.3-2.
  • [10] J. H. Busnaina, Z. Shi, Jesús M. Alcaine-Cuervo, Cindy X. Yang, I. Nsanzineza, E. Rico, and C. M. Wilson. Native three-body interactions in a superconducting lattice gauge quantum simulator, 2025. arXiv:2501.13383.
  • [11] Samuel R. Buss and Louise Hay. On truth-table reducibility to sat. Information and Computation, 91(1):86–102, March 1991. doi:10.1016/0890-5401(91)90075-d.
  • [12] Chris Cade, Marten Folkertsma, and Jordi Weggemans. Complexity of the guided local hamiltonian problem: Improved parameters and extension to excited states, 2024. arXiv:2207.10097.
  • [13] Jin-Yi Cai, Thomas Gundermann, Juris Hartmanis, Lane A. Hemachandra, Vivian Sewelson, Klaus Wagner, and Gerd Wechsung. The boolean hierarchy i: Structural properties. SIAM Journal on Computing, 17(6):1232–1252, December 1988. doi:10.1137/0217078.
  • [14] Ricardo Rivera Cardoso, Alex Meiburg, and Daniel Nagaj. Quantum sat problems with finite sets of projectors are complete for a plethora of classes, 2025. arXiv:2506.07244.
  • [15] Andrew M. Childs, David Gosset, and Zak Webb. The bose-hubbard model is qma-complete. Theory Comput., 11:491–603, 2015. doi:10.4086/TOC.2015.V011A020.
  • [16] Alexander Y. Chuang, Huan Q. Bui, Arthur Christianen, Yiming Zhang, Yiqi Ni, Denise Ahmed-Braun, Carsten Robens, and Martin W. Zwierlein. Observation of a halo trimer in an ultracold bose-fermi mixture, 2024. arXiv:2411.04820.
  • [17] R. Cruz-Torres, D. Nguyen, F. Hauenstein, A. Schmidt, S. Li, D. Abrams, H. Albataineh, S. Alsalmi, et al. Probing few-body nuclear dynamics via H3 and He3 (e,ep)pn cross-section measurements. Phys. Rev. Lett., 124:212501, 2020. doi:10.1103/PhysRevLett.124.212501.
  • [18] Toby Cubitt and Ashley Montanaro. Complexity classification of local hamiltonian problems. SIAM Journal on Computing, 45(2):268–316, 2016.
  • [19] Sevag Gharibian and Jamie Sikora. Ground state connectivity of local hamiltonians. ACM Trans. Comput. Theory, 10(2):8:1–8:28, 2018. doi:10.1145/3186587.
  • [20] Brett Giles and Peter Selinger. Exact synthesis of multiqubit clifford+t circuits. Phys. Rev. A, 87:032332, March 2013. doi:10.1103/PhysRevA.87.032332.
  • [21] David Gosset, Jenish C. Mehta, and Thomas Vidick. QCMA hardness of ground space connectivity for commuting Hamiltonians. Quantum, 1:16, July 2017. doi:10.22331/q-2017-07-14-16.
  • [22] David Gosset and Daniel Nagaj. Quantum 3-sat is 𝖰𝖬𝖠1-complete. SIAM Journal on Computing, 45(3):1080–1128, 2016. doi:10.1137/140957056.
  • [23] Sean Hallgren, Daniel Nagaj, and Sandeep Narayanaswami. The local hamiltonian problem on a line with eight states is qma-complete. Quantum Inf. Comput., 13(9-10):721–750, 2013. doi:10.26421/QIC13.9-10-1.
  • [24] Ying hao Chen. 2-local hamiltonian with low complexity is qcma, 2019. arXiv:1909.03787.
  • [25] Lane A. Hemachandra. The strong exponential hierarchy collapses. Journal of Computer and System Sciences, 39(3):299–322, December 1989. doi:10.1016/0022-0000(89)90025-1.
  • [26] Sandy Irani and Jiaqing Jiang. Commuting local hamiltonian problem on 2d beyond qubits, 2023. arXiv:2309.04910.
  • [27] Stephen P. Jordan, Hirotada Kobayashi, Daniel Nagaj, and Harumichi Nishimura. Achieving perfect completeness in classical-witness quantum merlin-arthur proof systems. Quantum Info. Comput., 12(5-6):461–471, 2012. doi:10.26421/QIC12.5-6-7.
  • [28] Julia Kempe, Alexei Kitaev, and Oded Regev. The Complexity of the Local Hamiltonian Problem, pages 372–383. Springer, 2004. doi:10.1007/978-3-540-30538-5_31.
  • [29] A Yu Kitaev. Quantum computations: algorithms and error correction. Russian Mathematical Surveys, 52(6):1191, 1997.
  • [30] Alexei Y. Kitaev, Alexander Shen, and Mikhail N. Vyalyi. Classical and Quantum Computation, volume 47 of Graduate studies in mathematics. American Mathematical Society, 2002. URL: https://bookstore.ams.org/gsm-47/.
  • [31] Yi-Kai Liu, Matthias Christandl, and F. Verstraete. Quantum computational complexity of the n-representability problem: Qma complete. Phys. Rev. Lett., 98:110503, 2007. doi:10.1103/PhysRevLett.98.110503.
  • [32] Alex Meiburg. Quantum constraint problems can be complete for 𝖡𝖰𝖯, 𝖰𝖢𝖬𝖠, and more, 2021. arXiv:2101.08381.
  • [33] Roberto Oliveira and Barbara M. Terhal. The complexity of quantum spin systems on a two-dimensional square lattice. Quantum Info. Comput., 8(10):900–924, 2008. doi:10.26421/QIC8.10-2.
  • [34] C.H. Papadimitriou and M. Yannakakis. The complexity of facets (and some facets of complexity). Journal of Computer and System Sciences, 28(2):244–259, April 1984. doi:10.1016/0022-0000(84)90068-0.
  • [35] Francesco Petiziol, Mahdi Sameti, Stefano Carretta, Sandro Wimberger, and Florian Mintert. Quantum simulation of three-body interactions in weakly driven quantum systems. Phys. Rev. Lett., 126:250504, June 2021. doi:10.1103/PhysRevLett.126.250504.
  • [36] Asad Raza, Jens Eisert, and Alex B. Grilo. Complexity of geometrically local stoquastic hamiltonians, 2024. arXiv:2407.15499.
  • [37] Dorian Rudolph. Towards a universal gateset for 𝖰𝖬𝖠1, 2024. arXiv:2411.02681.
  • [38] Thomas J. Schaefer. The complexity of satisfiability problems. In Proceedings of the Tenth Annual ACM Symposium on Theory of Computing, STOC ’78, pages 216–226, New York, NY, USA, 1978. Association for Computing Machinery. doi:10.1145/800133.804350.
  • [39] Norbert Schuch and Frank Verstraete. Computational complexity of interacting electrons and fundamental limitations of density functional theory. Nature physics, 5(10):732–735, 2009. doi:10.1038/nphys1370.
  • [40] Jordi Weggemans, Marten Folkertsma, and Chris Cade. Guidable Local Hamiltonian Problems with Implications to Heuristic Ansatz State Preparation and the Quantum PCP Conjecture. In 19th Conference on the Theory of Quantum Computation, Communication and Cryptography (TQC 2024), volume 310 of Leibniz International Proceedings in Informatics (LIPIcs), pages 10:1–10:24, Dagstuhl, Germany, 2024. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.TQC.2024.10.
  • [41] Tzu-Chieh Wei, Michele Mosca, and Ashwin Nayak. Interacting boson problems can be qma hard. Phys. Rev. Lett., 104:040501, 2010. doi:10.1103/PhysRevLett.104.040501.
  • [42] Pawel Wocjan, Dominik Janzing, and Thomas Beth. Two qcma-complete problems. Quantum Inf. Comput., 3(6):635–643, 2003. doi:10.26421/QIC3.6-7.
  • [43] Dmitriy Zhuk. A proof of the CSP dichotomy conjecture. J. ACM, 67(5):30:1–30:78, 2020. doi:10.1145/3402029.

Appendix A Notation and background

A.1 Notation

For a bitstring x, let |x| denote the number of bits in x.

A promise problem A=(Ayes,Ano) is a computational problem consisting of two non-intersecting sets Ayes,Ano{0,1} where given an instance x{0,1} (promised to be in one of the two sets), one is tasked to determine if xAyes (x is a yes-instance) or xAno (x is a no-instance).161616The asterisk over the set is known as the Kleene star and is used to represent strings of any finite size. If AyesAno={0,1}, then A is called a language. For an instance x, we let n=|x| denote the size of x.

For some complexity classes, we specify the gate set used. Here, we use the Clifford-cyclotomic gate sets 𝒢m defined in Ref. [4]. Specifically, we only consider those that are a power of two. These are: 𝒢2:={X,CNOT,Toffoli,HH}, 𝒢4:={X,CNOT,Toffoli,ζ8H}, and for l3, 𝒢2l:={H,CNOT,T2l}. Here, T2l=diag(1,ζ2l) where ζ2l=e2πi/2l is a primitive 2l-th root of unity.

In all quantum circuits considered here, we let U0=I be a dummy unitary used for convenience. The same is true for classical circuits Q and classical reversible circuits R. For circuits that decide computational problems, we let ans denote the qubit that when measured provides this decision. We accept the instance if the qubit is measured and yields outcome “1”, and reject otherwise. Usually, ans is the first ancilla qubit of the circuit.

For a circuit Un that decides an instance x with |x|=n, we denote Ux as the circuit where the instance x is encoded into it and the inputs are only ancilla qubits in the |0 state.

A.2 Classes with perfect completeness

This version of the paper assumes familiarity with basic complexity classes; for a detailed introduction, we refer the reader to the full version of the paper [14]. Here, we only discuss a variation of probabilistic complexity classes with perfect completeness.

These are the classes where the acceptance probability of yes-instances is equal to one, and they are one of the two types of classes with one-sided error. Although these classes appear to be similar to their two-sided error variation, quantum complexity classes with one-sided error require a more precise treatment as they are not known to be independent of the gate set used. Indeed, the Solovay-Kitaev theorem [29] used to resolve this issue for classes with two-sided error only works for approximate equivalence of universal gate sets and not perfect equivalence. Thus, for classes with one-sided error (with some exceptions), one must specify the gate set used by the quantum circuits. This is not the case for classical complexity classes as it is known that every classical circuit using gate set 𝒢 can be perfectly simulated by another circuit using a universal gate set 𝒢.

Given this discussion, we can then define one-sided error classes as follows:

Definition 23 (Classes with perfect completeness).

Let 𝒞 be a complexity class with two-sided error. The variant of this class with perfect completeness is defined in a similar way to 𝒞 except for the following differences:

  1. 1.

    For a promise problem A, the acceptance probability must be exactly 1 when xAyes.

  2. 2.

    If 𝒞 is a quantum complexity class, the gate set 𝒢 used by the quantum circuits {Un} must be specified.

The class is generally denoted as 𝒞1, or 𝒞1𝒢 if it is a quantum complexity class.

This sensibility to the gate set in quantum complexity classes is the reason why, in Theorems 1 and 2, we explicitly state that LCT-QSAT and SLCT-QSAT are complete for 𝖡𝖰𝖯1 with the particular choice of gate set 𝒢8. It also presents other complications. To see this, consider 𝖡𝖰𝖯. It is evident that 𝖡𝖰𝖯1𝒢𝖡𝖰𝖯 for any arbitrary gate set 𝒢, and also that 𝖯𝖡𝖰𝖯. However, is it true that 𝖯𝖡𝖰𝖯1𝒢? Fortunately, one can show that for the Clifford+T gate set (i.e. 𝒢8) used in this paper, the class 𝖡𝖰𝖯1𝒢8 follows the intuitive containment of classes.

Interestingly, Jordan et al. [27] showed that if the circuits that decide a 𝖰𝖢𝖬𝖠 problem consist of gates with a succinct representation (e.g. 𝒢8), the acceptance probability of yes-instances can be amplified additively to be exactly 1. In other words, they showed that 𝖰𝖢𝖬𝖠𝖰𝖢𝖬𝖠1𝒢8, concluding that 𝖰𝖢𝖬𝖠1𝒢8=𝖰𝖢𝖬𝖠. This explains why in Theorem 4 we state that the problem Witnessed SLCT-QSAT is 𝖰𝖢𝖬𝖠-complete. To this day, it remains an open question whether a similar scheme can also work for 𝖡𝖰𝖯 and 𝖰𝖬𝖠. In the case of 𝖰𝖬𝖠, it seems this is not the case as one can show that there exists an oracle for which 𝖰𝖬𝖠𝖰𝖢𝖬𝖠1 [1]. However, a similar claim was made about 𝖰𝖢𝖬𝖠 and 𝖰𝖢𝖬𝖠1.

A.3 k-QSAT & the Circuit-to-Hamiltonian transformation

Here, we introduce Quantum k-SAT (denoted here as k-QSAT) as presented by Gosset and Nagaj in Ref. [22]. We present relevant parts of the proofs showing that k-QSAT is contained in 𝖰𝖬𝖠1 for any constant k, and 𝖰𝖬𝖠1-hard for k6. While Bravyi’s [6] original work demonstrates hardness for k4, we choose to present this slightly weaker result for brevity, but also to introduce our clock encoding and notation useful for the rest of this paper.

As we are working to prove the inclusion and hardness of this problem for a class requiring perfect completeness, it is necessary to specify the gate set used by the quantum circuits. For reasons discussed below, we choose 𝒢8. In addition, we also have to be wary that all operations can be performed with perfect accuracy using gates from this set and all measurements are in the computational basis. For this purpose, Gosset and Nagaj introduce the following set of projectors.

Definition 24 (Perfectly measurable projectors).

Let 𝒫 be the set of projectors such that every matrix element in the computational basis is of the form 14(a+ib+2c+i2d) for all a,b,c,d.

The (promise) problem k-QSAT can be defined as follows.

Definition 25 (k-QSAT).

Given an integer n and an instance x consisting of a collection of projectors {Πi}𝒫 where each Πi acts nontrivially on at most k qubits, the problem consists on deciding whether (1) there exists an n-qubit state |ψsat such that Πi|ψsat=0 for all i, or (2) for every n-qubit state |ψ, Σiψ|Πi|ψ1/poly(n). We are promised that these are the only two cases. We output “YES” if (1) is true, or “NO” otherwise.

One can think of this problem as being presented with a list of constraints or clauses (the projectors Πi) and tasked with distinguishing between the following cases: (1) there exists a state that satisfies all constraints (a satisfying state), or (2) any possible state induces a violation of the constraints greater than 1/poly(n). The promise sets the conditions for classifying instances as either xAyes or xAno.171717Without the promise, the problem seems to become harder, as it requires distinguishing between the case where the projectors are satisfiable, and the case where they are not but the violation induced by some states could be exponentially close to zero. Without the promise, the problem is most likely not contained in 𝖰𝖬𝖠1.

A.3.1 In QMA1

Suppose we are presented with a witness state |ψwit and a k-QSAT instance composed of projectors {Πi}. The quantum algorithm that decides whether this state satisfies all projectors Πi consists of simply measuring the eigenvalues of all projectors on this state. Then, if all measured eigenvalues are 0, we conclude that all projectors are satisfied by the state and output “YES”. Otherwise, we reject.

Specifically, we measure the eigenvalue of a projector Πi by applying the unitary

V(Πi)=ΠiX+(IΠi)I, (2)

to the witness and an additional ancilla qubit in the state |0, followed by a measurement of the ancilla in the computational basis. Here, X denotes the Pauli-X gate. The probability that |ψwit does not satisfy projector Πi (obtain outcome “1”) is given by

pi=ψwit|Πi|ψwit. (3)

Defining the acceptance probability as the probability that all measurements produce outcome “0”, and assuming V(Πi) can be implemented perfectly with gate set 𝒢, one can show that this algorithm meets the completeness and soundness conditions of 𝖰𝖬𝖠1, concluding that k-QSAT is contained in this class.

As mentioned, to support this claim, it is necessary to demonstrate that V(Πi) can be implemented perfectly using gate set 𝒢8. This follows from the fact that the projectors Πi are from the set 𝒫 together with a theorem by Giles and Selinger [20].

A.3.2 QMA1-hard

Now, we discuss elements of the proof demonstrating that k-QSAT is 𝖰𝖬𝖠1-hard when k6 and for any gate set 𝒢 that is universal for quantum computation.

The idea is to demonstrate that any instance x of an arbitrary promise problem in 𝖰𝖬𝖠1 can be transformed or reduced in polynomial time into an instance x of k-QSAT, where the answer to both problems is the same for all instances. Furthermore, we also need to show that all projectors of the resulting k-QSAT instance act on at most 6 qubits.

Let Ux=ULU1 with Ui𝒢 and L=poly(n) be the 𝖰𝖬𝖠1 verification circuit where given an instance x of a problem A=(Ayes,Ano), Ux decides whether xAyes or xAno. The input to the circuit consists of the p-qubit witness state |ψwit, and a q-qubit ancilla register D (referred to as the data register) initialized to the state |0q, where p and q are two polynomials in n=|x|. Additionally, let the answer be obtained by measuring the ancilla qubit ans in the computational basis. The goal of the reduction is to engineer a set of 6-local projectors such that they are uniquely satisfied by the state encoding the evaluation of the circuit U on |ϕ0:=|0q|ψwit at all steps of the computation. This state is appropriately known as the (computational) history state and is given by

|ψhist:=1L+1t=0LUtU0|ϕ0D|CtC. (4)

Here, we have introduced a clock register C acting on a new (not yet specified) Hilbert space used to keep track of the current step in the computation. This history state can be defined in many ways depending on the implementation of the states |Ct. In this paper, we choose a clock encoding acting on clock=(3)L+1, consisting of the ready state |r, the active state |a, and the dead state |d. The clock progresses as

|C0 =|a0r1r2rL, (5)
|C1 =|d0a1r2rL,
|CL =|d0d1d2aL.

The projectors that allow us to build the required 6-QSAT instance act on both of these Hilbert spaces and are given by

Pinit(i) :=|11|i|aa|0, (6)
Pout(i) :=|00|i|aa|L,
Pprop,U(i):=12[I2|arar|+I2 |dada|U|daar|U|arda|],

which receive an index to specify its action on a given particle. Moreover, Pprop,U acts on clock qudits i1 and i. Observe that Pinit and Pout act on a single data and clock particle, while Pprop,U acts on two data qubits and two clock particles. As each clock particle can be represented by two qubits, albeit a bit wastefully, it is evident that these projectors are at most 6-local (on qubits). Other clock encodings may lead to different locality.181818In Ref. [6], Bravyi employs a four-state clock encoding, 2L+1 clock basis states, and an additional propagation projector. This allows interactions between either two clock particles at a time or one clock particle and two data qubits, resulting in 4-local projectors. However, this comes at a cost of increased clock particle dimensionality.

Figure 4: Representation of a 6-QSAT instance which encodes a 𝖰𝖬𝖠1 verification circuit U=ULU1. For simplicity, we let U act on four data qubits: two ancilla qubits (those present in Pinit clauses), and two for the witness state (uninitialized ones). The ancilla measured at the end of the computation is labeled ans. The leftmost and rightmost clock particles are marked with “start” and “stop” icons, indicating the action of Pstart and Pstop clauses, respectively. The Pclock clauses are shown as arrows on top of Pprop,U lines, representing the clock progression.

Each projector in Equation 6 penalizes states that do not meet certain requirements. (Initialization) Pinit requires that when clock particle 0 is in the state |a, data qubit i is initialized to |0. (Computational propagation) Pprop,U requires that as clock particles i and i+1 transition from |ar to |da, U is applied to two qubits of the data register. (Readout) Finally, Pout requires that when clock qudit L is in the state |a, data qubit i is in the state |1.191919Unlike Bravyi [6] and Meiburg [32], we define Pout so it is satisfied when the logical qubit is in the state |1, and not |0. Aside from these projectors, one also has to define

Pstart :=|rr|0, (7)
Pstop :=|dd|L,
Pclock(i):=|rr|i(I|rr|)i+1+|a a|i(I|rr|)i+1+|dd|i|rr|i+1,

which are at most 4-local projectors requiring that the clock states have the form described in Equation 5. Furthermore, the six types of projectors of Equations 6 and 7 are of the form given in Definition 24 and are hence projectors from 𝒫, as required. Finally, using these projectors, the instance that encodes the verifier circuit U=ULU1 is given by

Hinit :=bancillaPinit(b),
Hprop :=t=1LPprop,Ut(t)
Hout :=Pout(ans),
Hclock :=Pstart+Pstop+cCPclock(c).

We illustrate this instance in Figure 4. The set of projectors that define this k-QSAT instance are the individual terms of the sum. They are often grouped into positive semi-definite terms as above for historical reasons. Briefly, the Hinit term requires that all ancilla qubits from register D are initialized to |0, leaving the data qubits for the witness state “free” or uninitialized. Hprop defines a clock register of L+1 particles and requires that as time progresses from t1 to t, Ut is applied to the data qubits. Hout requires that at the end of the computation ans is measured to be “1”. Finally, Hclock requires that we obtain a running clock register progressing as shown in Equation 5. Together, Hinit,Hprop, and Hclock require that if there exists a state satisfying all of their projectors, the state must mimic the evaluation of the quantum circuit U=ULU1 on the state |ϕ0. This is the history state of Equation 4 with the clock encoding of Equation 5. Moreover, if the verification circuit U accepts yes-instances with certainty, the history state also satisfies Hout and is thus the unique ground state of the 6-local Hamiltonian H=Hinit+Hprop+Hout+Hclock.

This concludes the transformation of the circuit into local Hamiltonians. Completing the proof that 6-QSAT is 𝖰𝖬𝖠1-hard requires showing that, if xAyes, then x has a frustration-free ground state, and if xAno, then the ground state energy of H is not too low. Proving these is beyond the scope of this section.