DOCSLIB.ORG

Lecture 20: Local Hamiltonian Ground State Problems

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
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: 푥 =⇒ 퐶 (푥, 푦, 푧).
Load more

Recommended publications
  • Slides 6, HT 2019 Space Complexity
    Computational Complexity; slides 6, HT 2019 Space complexity Prof. Paul W. Goldberg (Dept. of Computer Science, University of Oxford) HT 2019 Paul Goldberg Space complexity 1 / 51 Road map I mentioned classes like LOGSPACE (usually calledL), SPACE(f (n)) etc. How do they relate to each other, and time complexity classes? Next: Various inclusions can be proved, some more easy than others; let's begin with \low-hanging fruit"... e.g., I have noted: TIME(f (n)) is a subset of SPACE(f (n)) (easy!) We will see e.g.L is a proper subset of PSPACE, although it's unknown how they relate to various intermediate classes, e.g.P, NP Various interesting problems are complete for PSPACE, EXPTIME, and some of the others. Paul Goldberg Space complexity 2 / 51 Convention: In this section we will be using Turing machines with a designated read only input tape. So, \logarithmic space" becomes meaningful. Space Complexity So far, we have measured the complexity of problems in terms of the time required to solve them. Alternatively, we can measure the space/memory required to compute a solution. Important difference: space can be re-used Paul Goldberg Space complexity 3 / 51 Space Complexity So far, we have measured the complexity of problems in terms of the time required to solve them. Alternatively, we can measure the space/memory required to compute a solution. Important difference: space can be re-used Convention: In this section we will be using Turing machines with a designated read only input tape. So, \logarithmic space" becomes meaningful. Paul Goldberg Space complexity 3 / 51 Definition.
    [Show full text]
  • NP-Completeness: Reductions Tue, Nov 21, 2017
    CMSC 451 Dave Mount CMSC 451: Lecture 19 NP-Completeness: Reductions Tue, Nov 21, 2017 Reading: Chapt. 8 in KT and Chapt. 8 in DPV. Some of the reductions discussed here are not in either text. Recap: We have introduced a number of concepts on the way to defining NP-completeness: Decision Problems/Language recognition: are problems for which the answer is either yes or no. These can also be thought of as language recognition problems, assuming that the input has been encoded as a string. For example: HC = fG j G has a Hamiltonian cycleg MST = f(G; c) j G has a MST of cost at most cg: P: is the class of all decision problems which can be solved in polynomial time. While MST 2 P, we do not know whether HC 2 P (but we suspect not). Certificate: is a piece of evidence that allows us to verify in polynomial time that a string is in a given language. For example, the language HC above, a certificate could be a sequence of vertices along the cycle. (If the string is not in the language, the certificate can be anything.) NP: is defined to be the class of all languages that can be verified in polynomial time. (Formally, it stands for Nondeterministic Polynomial time.) Clearly, P ⊆ NP. It is widely believed that P 6= NP. To define NP-completeness, we need to introduce the concept of a reduction. Reductions: The class of NP-complete problems consists of a set of decision problems (languages) (a subset of the class NP) that no one knows how to solve efficiently, but if there were a polynomial time solution for even a single NP-complete problem, then every problem in NP would be solvable in polynomial time.
    [Show full text]
  • Mapping Reducibility and Rice's Theorem
    6.045: Automata, Computability, and Complexity Or, Great Ideas in Theoretical Computer Science Spring, 2010 Class 9 Nancy Lynch Today • Mapping reducibility and Rice’s Theorem • We’ve seen several undecidability proofs. • Today we’ll extract some of the key ideas of those proofs and present them as general, abstract definitions and theorems. • Two main ideas: – A formal definition of reducibility from one language to another. Captures many of the reduction arguments we have seen. – Rice’s Theorem, a general theorem about undecidability of properties of Turing machine behavior (or program behavior). Today • Mapping reducibility and Rice’s Theorem • Topics: – Computable functions. – Mapping reducibility, ≤m – Applications of ≤m to show undecidability and non- recognizability of languages. – Rice’s Theorem – Applications of Rice’s Theorem • Reading: – Sipser Section 5.3, Problems 5.28-5.30. Computable Functions Computable Functions • These are needed to define mapping reducibility, ≤m. • Definition: A function f: Σ1* →Σ2* is computable if there is a Turing machine (or program) such that, for every w in Σ1*, M on input w halts with just f(w) on its tape. • To be definite, use basic TM model, except replace qacc and qrej states with one qhalt state. • So far in this course, we’ve focused on accept/reject decisions, which let TMs decide language membership. • That’s the same as computing functions from Σ* to { accept, reject }. • Now generalize to compute functions that produce strings. Total vs. partial computability • We require f to be total = defined for every string. • Could also define partial computable (= partial recursive) functions, which are defined on some subset of Σ1*.
    [Show full text]
  • The Complexity Zoo
    The Complexity Zoo Scott Aaronson www.ScottAaronson.com LATEX Translation by Chris Bourke [email protected] 417 classes and counting 1 Contents 1 About This Document 3 2 Introductory Essay 4 2.1 Recommended Further Reading ......................... 4 2.2 Other Theory Compendia ............................ 5 2.3 Errors? ....................................... 5 3 Pronunciation Guide 6 4 Complexity Classes 10 5 Special Zoo Exhibit: Classes of Quantum States and Probability Distribu- tions 110 6 Acknowledgements 116 7 Bibliography 117 2 1 About This Document What is this? Well its a PDF version of the website www.ComplexityZoo.com typeset in LATEX using the complexity package. Well, what’s that? The original Complexity Zoo is a website created by Scott Aaronson which contains a (more or less) comprehensive list of Complexity Classes studied in the area of theoretical computer science known as Computa- tional Complexity. I took on the (mostly painless, thank god for regular expressions) task of translating the Zoo’s HTML code to LATEX for two reasons. First, as a regular Zoo patron, I thought, “what better way to honor such an endeavor than to spruce up the cages a bit and typeset them all in beautiful LATEX.” Second, I thought it would be a perfect project to develop complexity, a LATEX pack- age I’ve created that defines commands to typeset (almost) all of the complexity classes you’ll find here (along with some handy options that allow you to conveniently change the fonts with a single option parameters). To get the package, visit my own home page at http://www.cse.unl.edu/~cbourke/.
    [Show full text]
  • Arxiv:1506.08857V1 [Quant-Ph] 29 Jun 2015
    Absolutely Maximally Entangled states, combinatorial designs and multi-unitary matrices Dardo Goyeneche National Quantum Information Center of Gda´nsk,81-824 Sopot, Poland and Faculty of Applied Physics and Mathematics, Technical University of Gda´nsk,80-233 Gda´nsk,Poland Daniel Alsina Dept. Estructura i Constituents de la Mat`eria,Universitat de Barcelona, Spain. Jos´e I. Latorre Dept. Estructura i Constituents de la Mat`eria,Universitat de Barcelona, Spain. and Center for Theoretical Physics, MIT, USA Arnau Riera ICFO-Institut de Ciencies Fotoniques, Castelldefels (Barcelona), Spain Karol Zyczkowski_ Institute of Physics, Jagiellonian University, Krak´ow,Poland and Center for Theoretical Physics, Polish Academy of Sciences, Warsaw, Poland (Dated: June 29, 2015) Absolutely Maximally Entangled (AME) states are those multipartite quantum states that carry absolute maximum entanglement in all possible partitions. AME states are known to play a relevant role in multipartite teleportation, in quantum secret sharing and they provide the basis novel tensor networks related to holography. We present alternative constructions of AME states and show their link with combinatorial designs. We also analyze a key property of AME, namely their relation to tensors that can be understood as unitary transformations in every of its bi-partitions. We call this property multi-unitarity. I. INTRODUCTION entropy S(ρ) = −Tr(ρ log ρ) ; (1) A complete characterization, classification and it is possible to show [1, 2] that the average entropy quantification of entanglement for quantum states re- of the reduced state σ = TrN=2j ih j to N=2 qubits mains an unfinished long-term goal in Quantum Infor- reads: N mation theory.
    [Show full text]
  • Non-Unitary Quantum Computation in the Ground Space of Local Hamiltonians
    Non-Unitary Quantum Computation in the Ground Space of Local Hamiltonians Na¨ıri Usher,1, ∗ Matty J. Hoban,2, 3 and Dan E. Browne1 1Department of Physics and Astronomy, University College London, Gower Street, London WC1E 6BT, United Kingdom. 2University of Oxford, Department of Computer Science, Wolfson Building, Parks Road, Oxford OX1 3QD, United Kingdom. 3School of Informatics, University of Edinburgh, 10 Crichton Street, Edinburgh EH8 9AB, UK A central result in the study of Quantum Hamiltonian Complexity is that the k-local hamilto- nian problem is QMA-complete [1]. In that problem, we must decide if the lowest eigenvalue of a Hamiltonian is bounded below some value, or above another, promised one of these is true. Given the ground state of the Hamiltonian, a quantum computer can determine this question, even if the ground state itself may not be efficiently quantum preparable. Kitaev's proof of QMA-completeness encodes a unitary quantum circuit in QMA into the ground space of a Hamiltonian. However, we now have quantum computing models based on measurement instead of unitary evolution, further- more we can use post-selected measurement as an additional computational tool. In this work, we generalise Kitaev's construction to allow for non-unitary evolution including post-selection. Fur- thermore, we consider a type of post-selection under which the construction is consistent, which we call tame post-selection. We consider the computational complexity consequences of this construc- tion and then consider how the probability of an event upon which we are post-selecting affects the gap between the ground state energy and the energy of the first excited state of its corresponding Hamiltonian.
    [Show full text]
  • Zero-Knowledge Proof Systems
    Extracted from a working draft of Goldreich's FOUNDATIONS OF CRYPTOGRAPHY. See copyright notice. Chapter ZeroKnowledge Pro of Systems In this chapter we discuss zeroknowledge pro of systems Lo osely sp eaking such pro of systems have the remarkable prop erty of b eing convincing and yielding nothing b eyond the validity of the assertion The main result presented is a metho d to generate zero knowledge pro of systems for every language in NP This metho d can b e implemented using any bit commitment scheme which in turn can b e implemented using any pseudorandom generator In addition we discuss more rened asp ects of the concept of zeroknowledge and their aect on the applicabili ty of this concept Organization The basic material is presented in Sections through In particular we start with motivation Section then we dene and exemplify the notions of inter active pro ofs Section and of zeroknowledge Section and nally we present a zeroknowledge pro of systems for every language in NP Section Sections dedicated to advanced topics follow Unless stated dierently each of these advanced sections can b e read indep endently of the others In Section we present some negative results regarding zeroknowledge pro ofs These results demonstrate the optimality of the results in Section and mo tivate the variants presented in Sections and In Section we present a ma jor relaxion of zeroknowledge and prove that it is closed under parallel comp osition which is not the case in general for zeroknowledge In Section we dene and discuss zeroknowledge pro ofs of knowledge In Section we discuss a relaxion of interactive pro ofs termed computationally sound pro ofs or arguments In Section we present two constructions of constantround zeroknowledge systems The rst is an interactive pro of system whereas the second is an argument system Subsection is a prerequisite for the rst construction whereas Sections and constitute a prerequisite for the second Extracted from a working draft of Goldreich's FOUNDATIONS OF CRYPTOGRAPHY.
    [Show full text]
  • The Satisfiability Problem
    The Satisfiability Problem Cook’s Theorem: An NP-Complete Problem Restricted SAT: CSAT, 3SAT 1 Boolean Expressions ◆Boolean, or propositional-logic expressions are built from variables and constants using the operators AND, OR, and NOT. ◗ Constants are true and false, represented by 1 and 0, respectively. ◗ We’ll use concatenation (juxtaposition) for AND, + for OR, - for NOT, unlike the text. 2 Example: Boolean expression ◆(x+y)(-x + -y) is true only when variables x and y have opposite truth values. ◆Note: parentheses can be used at will, and are needed to modify the precedence order NOT (highest), AND, OR. 3 The Satisfiability Problem (SAT ) ◆Study of boolean functions generally is concerned with the set of truth assignments (assignments of 0 or 1 to each of the variables) that make the function true. ◆NP-completeness needs only a simpler Question (SAT): does there exist a truth assignment making the function true? 4 Example: SAT ◆ (x+y)(-x + -y) is satisfiable. ◆ There are, in fact, two satisfying truth assignments: 1. x=0; y=1. 2. x=1; y=0. ◆ x(-x) is not satisfiable. 5 SAT as a Language/Problem ◆An instance of SAT is a boolean function. ◆Must be coded in a finite alphabet. ◆Use special symbols (, ), +, - as themselves. ◆Represent the i-th variable by symbol x followed by integer i in binary. 6 SAT is in NP ◆There is a multitape NTM that can decide if a Boolean formula of length n is satisfiable. ◆The NTM takes O(n2) time along any path. ◆Use nondeterminism to guess a truth assignment on a second tape.
    [Show full text]
  • CS286.2 Lectures 5-6: Introduction to Hamiltonian Complexity, QMA-Completeness of the Local Hamiltonian Problem
    CS286.2 Lectures 5-6: Introduction to Hamiltonian Complexity, QMA-completeness of the Local Hamiltonian problem Scribe: Jenish C. Mehta The Complexity Class BQP The complexity class BQP is the quantum analog of the class BPP. It consists of all languages that can be decided in quantum polynomial time. More formally, Definition 1. A language L 2 BQP if there exists a classical polynomial time algorithm A that ∗ maps inputs x 2 f0, 1g to quantum circuits Cx on n = poly(jxj) qubits, where the circuit is considered a sequence of unitary operators each on 2 qubits, i.e Cx = UTUT−1...U1 where each 2 2 Ui 2 L C ⊗ C , such that: 2 i. Completeness: x 2 L ) Pr(Cx accepts j0ni) ≥ 3 1 ii. Soundness: x 62 L ) Pr(Cx accepts j0ni) ≤ 3 We say that the circuit “Cx accepts jyi” if the first output qubit measured in Cxjyi is 0. More j0i specifically, letting P1 = j0ih0j1 be the projection of the first qubit on state j0i, j0i 2 Pr(Cx accepts jyi) =k (P1 ⊗ In−1)Cxjyi k2 The Complexity Class QMA The complexity class QMA (or BQNP, as Kitaev originally named it) is the quantum analog of the class NP. More formally, Definition 2. A language L 2 QMA if there exists a classical polynomial time algorithm A that ∗ maps inputs x 2 f0, 1g to quantum circuits Cx on n + q = poly(jxj) qubits, such that: 2q i. Completeness: x 2 L ) 9jyi 2 C , kjyik2 = 1, such that Pr(Cx accepts j0ni ⊗ 2 jyi) ≥ 3 2q 1 ii.
    [Show full text]
  • Restricted Versions of the Two-Local Hamiltonian Problem
    The Pennsylvania State University The Graduate School Eberly College of Science RESTRICTED VERSIONS OF THE TWO-LOCAL HAMILTONIAN PROBLEM A Dissertation in Physics by Sandeep Narayanaswami c 2013 Sandeep Narayanaswami Submitted in Partial Fulfillment of the Requirements for the Degree of Doctor of Philosophy August 2013 The dissertation of Sandeep Narayanaswami was reviewed and approved* by the following: Sean Hallgren Associate Professor of Computer Science and Engineering Dissertation Adviser, Co-Chair of Committee Nitin Samarth Professor of Physics Head of the Department of Physics Co-Chair of Committee David S Weiss Professor of Physics Jason Morton Assistant Professor of Mathematics *Signatures are on file in the Graduate School. Abstract The Hamiltonian of a physical system is its energy operator and determines its dynamics. Un- derstanding the properties of the ground state is crucial to understanding the system. The Local Hamiltonian problem, being an extension of the classical Satisfiability problem, is thus a very well-motivated and natural problem, from both physics and computer science perspectives. In this dissertation, we seek to understand special cases of the Local Hamiltonian problem in terms of algorithms and computational complexity. iii Contents List of Tables vii List of Tables vii Acknowledgments ix 1 Introduction 1 2 Background 6 2.1 Classical Complexity . .6 2.2 Quantum Computation . .9 2.3 Generalizations of SAT . 11 2.3.1 The Ising model . 13 2.3.2 QMA-complete Local Hamiltonians . 13 2.3.3 Projection Hamiltonians, or Quantum k-SAT . 14 2.3.4 Commuting Local Hamiltonians . 14 2.3.5 Other special cases . 15 2.3.6 Approximation Algorithms and Heuristics .
    [Show full text]
  • Homework 4 Solutions Uploaded 4:00Pm on Dec 6, 2017 Due: Monday Dec 4, 2017
    CS3510 Design & Analysis of Algorithms Section A Homework 4 Solutions Uploaded 4:00pm on Dec 6, 2017 Due: Monday Dec 4, 2017 This homework has a total of 3 problems on 4 pages. Solutions should be submitted to GradeScope before 3:00pm on Monday Dec 4. The problem set is marked out of 20, you can earn up to 21 = 1 + 8 + 7 + 5 points. If you choose not to submit a typed write-up, please write neat and legibly. Collaboration is allowed/encouraged on problems, however each student must independently com- plete their own write-up, and list all collaborators. No credit will be given to solutions obtained verbatim from the Internet or other sources. Modifications since version 0 1. 1c: (changed in version 2) rewored to showing NP-hardness. 2. 2b: (changed in version 1) added a hint. 3. 3b: (changed in version 1) added comment about the two loops' u variables being different due to scoping. 0. [1 point, only if all parts are completed] (a) Submit your homework to Gradescope. (b) Student id is the same as on T-square: it's the one with alphabet + digits, NOT the 9 digit number from student card. (c) Pages for each question are separated correctly. (d) Words on the scan are clearly readable. 1. (8 points) NP-Completeness Recall that the SAT problem, or the Boolean Satisfiability problem, is defined as follows: • Input: A CNF formula F having m clauses in n variables x1; x2; : : : ; xn. There is no restriction on the number of variables in each clause.
    [Show full text]
  • 11 Reductions We Mentioned Above the Idea of Solving Problems By
    11 Reductions We mentioned above the idea of solving problems by translating them into known soluble problems, or showing that a new problem is insoluble by translating a known insoluble into it. Reductions are the formal tool to implement this idea. It turns out that there are several subtly different variations – we will mainly use one form of reduction, which lets us make a fine analysis of uncomputability. First, we introduce a technical term for a Register Machine whose purpose is to translate one problem into another. Definition 12 A Turing transducer is an RM that takes an instance d of a problem (D, Q) in R0 and halts with an instance d0 = f(d) of (D0,Q0) in R0. / Thus f must be a computable function D D0 that translates the problem, and the → transducer is the machine that computes f. Now we define: Definition 13 A mapping reduction or many–one reduction from Q to Q0 is a Turing transducer f as above such that d Q iff f(d) Q0. Iff there is an m-reduction from Q ∈ ∈ to Q0, we write Q Q0 (mnemonic: Q is less difficult than Q0). / ≤m The standard term for these is ‘many–one reductions’, because the function f can be many–one – it doesn’t have to be injective. Our textbook Sipser doesn’t like that term, and calls them ‘mapping reductions’. To hedge our bets, and for brevity, we’ll call them m-reductions. Note that the reduction is just a transducer (i.e. translates the problem) that translates correctly (so that the answer to the translated problem is the same as the answer to the original).
    [Show full text]