Lecture 20: Local Hamiltonian Ground State Problems

Lecture 20: Local Hamiltonian Ground State Problems

Lecture 20: Local Hamiltonian ground state problems Substitute lecturer: Richard Kueng, [email protected] Ph219/CS219, Fall 2019 John Preskill December 4, 2019 1 Agenda and Motivation 1. Motivation 2. Recapitulation: classical complexity (a) The problem class NP (b) Circuit-SAT reduces to 3-SAT 3. Classical local Hamiltonian ground state problems are NP-hard 4. The quantum Hamiltonian problem and the problem class QMA (a) The quantum 푘-local Hamiltonian problem (b) The problem class QMA The quantum Hamiltonian Ground state problem is QMA-complete (a) 푘-local Hamiltonian is in QMA (b) Roadmap (c) Constructing the Hamiltonian (d) Converting completeness into a small ground state energy (e) Converting soundness into a large ground state energy (f) Establishing locality 5. Summary The task of computing ground state energy of structured Hamiltonians is an impor- tant problem in physics with numerous applications ranging from solid state physics to ab initio quantum chemistry. We actually expect that quantum computers can compute such energies even in cases where classical computers may struggle. In fact, this might be one of the most important applications of future quantum computers. On the other hand, we believe that even quantum computers may struggle to compute ground state energies in some cases – even if the Hamiltonian is structured. Today, we will explore the reasons for such beliefs. A comment on structured Hamiltonians Physicists are often interested in translation- invariant geometrically local Hamiltonians, where all qubits interact the same way with their neighbors (modulo qubits at the boundary). Such Hamiltonians can provide good models for some real materials. However, Hamiltonians that lack translation invariance can also be interesting. For example, they may model a material with “disorder” due to imperfections (like dirt) in the sample. For such non-translation invariant Hamiltonians, 2 we have to specify how the local Hamiltonians vary from site to site in the system. Hamiltonians of this form are often called “spin glasses” for reasons that will become clear throughout the course of today’s lecture. 2 Classical complexity theory 2.1 Recapitulation: the problem classes P and NP Computation complexity is the study of how hard a certain computational task is. Digital computational tasks are formulated as languages. If 푓 is a uniform family of Boolean functions 푓 : {0, 1}* → {0, 1}, then the set of input strings accepted by 푓 is called the associated language: 퐿 = {푥 ∈ {0, 1}* : 푓(푥) = 1}. A language 퐿 is in P if and only if there exists a uniform classical circuit family 퐶 (traditionally: a deterministic Turing machine) such that 1. (Polynomial scaling) the size of 퐶(푥) scales polynomially in all input sizes. 2. (Completeness) For all 푥 ∈ 퐿, 퐶(푥) = 1. 3. (Soundness) For all 푥∈ / 퐿, 퐶(푥) = 0. P encompasses all computational tasks that are (classically) easy in the sense that they only require polynomial circuit size (runtime). If we increase the input size, the resulting overhead only increases polynomially. * Example 2.1 (Palindrome is in P). A string 푥 = 푥1푥2 ··· 푥푛 ∈ {0, 1} is in the language palindrome if it is equal to its own reversal: 푥1푥2 ··· 푥푛 = 푥푛푥푛−1 ··· 푥1. To see this, simply construct a circuit that reverses 푥 and checks whether the reversal of 푥 equals 푥 itself. We leave it as an exercise to check that the size of such a circuit grows linearly in the input length 푛. Another important problem class is NP. Roughly speaking, this problem class contains all problems that can be verified efficiently. A language 퐿 is in NP if and only if there exists a uniform classical circuit family 푉 (푥, 푦) – the verifier – (traditionally: a deterministic Turing machine) such that 1. (Polynomial scaling) the size of the verifier 푉 (푥, 푦) scales polynomially in the inputs 푥 and 푦. 2. (Completeness) If 푥 ∈ 퐿, then there exists a witness 푦 of polynomial size such that 푉 (푥, 푦) = 1. 3. If 푥∈ / 퐿, then no poly-size witness 푦 can fool the verifier: 푉 (푥, 푦) = 0 for all 푦 of polynomial size. 푛 Example 2.2 (Circuit-SAT is in NP). A Boolean circuit 퐶 : {0, 1} → {0, 1} comprised of poly(푛) gates is in the language Circuit-SAT if there exists an input 푥 ∈ {0, 1}푛 such that 퐶(푥) = 1. This problem is in NP. Suppose that 퐶 ∈ 퐿. Then, there exists a bit 3 string 푥 ∈ {0, 1}푛 such that 퐶(푥) = 1. This bit string verifies the language. Provided access to 푥, we can run the circuit 퐶 and verify membership (completeness). Conversely, if 퐶∈ / 퐿, then no input 푥 exists, where the circuit evaluates to one (soundness). We emphasize that the problem class NP makes no assumption on how difficult it is to actually solve a problem. It merely ensures that proposed solutions can be efficiently checked for correctness. Note, that this feature is true, in particular, for problems in P: simply compute the answer in polynomial size (time) and output the solution as a witness. Therefore, P ⊂ NP which intuitively makes sense. Checking correctness of a problem solution is not more difficult than coming up with a solution yourself. Interestingly, despite decades of active research, this is about as much as we know about the relationship between these two problem classes. Although widely believed to be true, the P ̸= NP conjecture is still open and, in fact, one of the $1 million dollar problems from the Clay Mathematics Institute. This lack of separation between intuitively meaningful problem classes makes it extremely difficult to determine the hardness of a computational task in absolute terms. Discontent with this state of the art, computer scientists have developed a rigorous formalism to assert relative hardness. Problem 퐵 is at least as hard as problem 퐴 if there exists a compiler – a polynomial-size uniform classical circuit family 푅 – that maps 푥 to 푅(푥) such that 퐵 accepts 푥 if and only if 퐴 accepts 푅(푥). Such a compilation procedure reduces problem 퐴 to an instance of problem 퐵. If we could find an ingenious way to solve problem 퐵, we could also solve problem 퐴 with moderate overhead only. A problem/language 퐿 is NP-complete, if it is contained in NP and every other NP-problem can be reduced to 퐿. NP-complete problems are at the heart of the problem class NP: if you can solve only one of them efficiently, then you could solve all NP-problems efficiently as well (“one to rule them all”). This seems likeavery strong condition, so it may seem surprising that NP-complete problems exist at all. Nonetheless, Karp came up with a list of 21 different NP-complete problems. This list contains famous problems like MAXCUT, traveling salesman, integer programming and has been greatly expanded since. The following example, however, is the quintessential example of an NP-complete problem. Example 2.3 (푘-SAT is NP-complete for 푘 ≥ 3). The input to 푘-SAT is a Boolean formula on 푛 variables 푥1, . , 푥푛 ∈ {0, 1} that is a conjunction of polynomially many clauses that are comprised of 푘 variables each, e.g. 푓(푥1, . , 푥푛) = (푥1 ∨ 푥5 ∨ 푥¯2) ∧ (푥4 ∨ 푥¯5 ∨ 푥3) ∧ · · · ∧ (푥푛 ∨ 푥푛−1 ∨ 푥¯1) is an example of a 3-SAT formula in conjunctive normal form. Here, 푥¯푖 denotes the negation of 푥푖. 푘-SAT is the language specified by the following rules: 푛 1. SAT(푓) = 1 if there exists 푥 = 푥1 ··· 푥푛 ∈ {0, 1} such that 푓(푥) = 1. 2. SAT(푓) = 0 otherwise. In words: A boolean formula 푓 is in 푘-SAT if the formula obeys the structural constraints (conjunction of clauses with 푘 terms each) and there exists a satisfiable assignment 푥, such that the formula evaluates to one (true). 4 Cook and Levin showed NP-completeness of 푘-SAT, by reducing the verification procedure associated with any NP-problem to an instance of a satisfiability problem. They cleverly converted the “there exists an efficient verifier”-part of the definition of an NP-problem into a “there exists an assignment that satisfies all the clauses” condition, i.e. 푘-SAT. We will see a variant of such an argument below, when we reduce Circuit-SAT to 3-SAT. Since we already know that Circuit-SAT is NP-complete, this reduction will provide an alternative proof of the Cook-Levin Theorem for 푘 = 3. Finally, we point out that it is relatively easy to reduce any 푘-SAT problem with 푘 ≥ 3 to 3-SAT by introducing dummy variables and reformulating the clauses in a given Boolean formula. Conversely, it is relatively straightforward to check that 1-SAT is an easy problem. More interestingly and less obvious is the insight that 2-SAT is also easy: 2-SAT ∈ P, while 3-SAT is NP-complete. 2.2 Circuit-SAT reduces to 3-SAT We will now show that Circuit-SAT (Example 2.2 ) reduces to 3-SAT (Example 2.3). To do so, we must find a compilation function that maps a classical circuit 퐶 : {0, 1}푛 → {0, 1} – the input of Circuit-SAT – to a Boolean formula in conjunctive form, where each clause contains exactly 3 variables. To do so, we suppose that the circuit 퐶 is comprised of 푚 = poly(푛) gates chosen form a universal gate set (e.g. AND, OR, NOT) such that each gate has at most 2 inputs and one output. The reduction of Circuit-SAT to 3-SAT is then based on reformulating the individual gates as clauses. To do so, we introduce a variable for the output of each gate and replace each gate with a clause: 푥 =⇒ 퐶 (푥, 푦, 푧).

View Full Text

Details

  • File Type
    pdf
  • Upload Time
    -
  • Content Languages
    English
  • Upload User
    Anonymous/Not logged-in
  • File Pages
    17 Page
  • File Size
    -

Download

Channel Download Status
Express Download Enable

Copyright

We respect the copyrights and intellectual property rights of all users. All uploaded documents are either original works of the uploader or authorized works of the rightful owners.

  • Not to be reproduced or distributed without explicit permission.
  • Not used for commercial purposes outside of approved use cases.
  • Not used to infringe on the rights of the original creators.
  • If you believe any content infringes your copyright, please contact us immediately.

Support

For help with questions, suggestions, or problems, please contact us