DOCSLIB.ORG

CSE 555: Homework 5

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
CSE 555: Homework 5 CSE 555: Homework 5 Spring 2015 April 27, 2015 (1) P = coP : Let L 2 P . So there is a deterministic Turing machine M that decides L in polynomial time. By swapping the accept and reject states of M, we obtain a deterministic Turing machine M 0 that decides L¯ in polynomial time. So L¯ 2 P , i.e. L 2 coP . Similarly, for L0 2 coP , we can show that L0 2 P . P SP ACE = NP SP ACE : By Savitch’s theorem. P SP ACE = coP SP ACE : Let L 2 P SP ACE. So there is a deterministic Turing machine M that decides L using polynomial space. By swapping the accept and reject states of M, we obtain a deterministic Turing machine M 0 that decides L¯ in polynomial space. So P SP ACE ⊆ coP SP ACE. Similarly, for L0 2 coP SP ACE , using the same technique L0 2 P SP ACE. coP SP ACE = coNP SP ACE : Let L 2 coP SP ACE. So L¯ 2 P SP ACE ⊆ NP SP ACE. Therefore, L 2 coNP SP ACE. When L0 2 coNP SP ACE, L 2 coSP ACE, by Savitch’s theorem. Based on what we know, it is possible that • P , NP , coNP , and P SP ACE are all distinct so there are four different complexity classes. • NP = coNP but P , NP , and P SP ACE are all distinct so there are three different complexity classes. • P = NP = coNP but P and P SP ACE are distinct so there are two different complexity classes. • P = P SP ACE so there is only one complexity class. We think that there are four. (2) Let us first define the following recursive algorithm, M =“On input hG; k; Ai, where G = (V; E) is a graph, k is an integer, and A is an array which is indexed by the vertices, and which keeps count of how many times a vertex has been chosen by the producer. 1. For each subset P ⊆ V , (a) Make a copy of A called A0. (b) For x 2 P , i. update A0[x] = A0[x] + 1. ii. if A0[x] > k, then accept. (c) Set ALL = true. (d) For each independent set C ⊆ S, 1 i. If V − C = φ or M recursively running on hG0; k; A0i rejects, then set ALL = false and break; where G0 is the graph obtained from G by deleting all the vertices from C. (e) If ALL = true , then accept. 2. Reject.” Now we define the following algorithm to decide PAINT, M 0 =“On input hG; ki, where G is a graph, and k is an integer, 1. Run M on hG; k; Ai, A is an all zero array. 2. If M accepts then accept, else reject.” The recursive call stack of M has O(n) levels. At each level we need to store the remaining graph G; the integer k, and the count array A. So we again need O(n) storage at each level. Therefore, the algorithm runs in O(n2) space. (3) First we show that PILF is in P SP ACE. The following recursive algorithm decides PILF in polynomial space. R =“On input hT; P; Ai, where T is a list of tiles, P is a variable taking values from a binary alphabet fh; bg, and A is an array of length 2l (the first l positions corresponds to the top l positions, and the remaining positions corresponds to the bottom l positions), 1. If T is an empty list, then accept, if A is an all-zero array, otherwise reject. 2. If P = h (i.e. the current player is Hole), then recursively call R on hT 0; b; Ai, where T 0 is obtained from T by removing the first tile, and A is updated with zeros in all the positions where the first tile had a zero; first, if the first tile is left as it is, and then if it is turned upside down. If either result is accept, then accept, otherwise reject. 3. If P = b (i.e. the current player is Block), then recursively call R on hT 0; h; Ai, where T 0 is obtained from T by removing the first tile, and A is updated with zeros in all the positions where the first tile had a zero; first, if the first tile is left as it is, and then if it is turned upside down. If both results are accept, then accept, otherwise reject.” Given an instance hT i, we run R on hT; h; Ai, where A is an all-one array of length 2l, and accept if R accepts, otherwise reject. Again the depth of the recursion is O(n), and each level uses O(nl) space. So R decides PILF in O(n2l) space. We reduce FORMULA-GAME to PILF. The reduction is same as the one for reducing SAT to FLIP in homework 4. If the instance 9x18x2 ::: Qxk[ ] belongs to FORMULA-GAME, then the player E has a winning strategy, i.e. a way of choosing True/False values for its variables such that all the clauses in are true. In that case player Hole can choose corresponding orientations for its tiles so that for each of the 2l positions, at least one tile has a 0 in that position. Similarly, if Hole has a winning strategy, then by construction, player E can choose True/False values in such a way that all the clauses in are true. The reduction operates in deterministic polynomial time. (4) R =“On input hG; P i, where G is a graph, and P is a variable taking values from the binary alphabet fOne; T wog, 2 1. If the G does not have any edges, then check if G has more than one vertex. If it does then reject, otherwise accept. 2. If P = One, (i.e. it is player One’s turn) then for each edge of G, build a new graph G0 by deleting that edge from G, and recursively run R on input hG0; T woi. If all the results are accept, then accept, otherwise reject. 3. If P = T wo, (i.e. it is player Two’s turn) then for each edge of G, build a new graph G00 by contracting the edge (i.e. by deleting the end points of the edge, adding a new vertex to the graph, and joining the new vertex to all the vertices that were adjacent to the deleted vertices), and recursively run R on input hG00; Onei. If any of the results is accept, then accept, otherwise reject.” Given an input hGi, we run R on hG; Onei, and accept when R accepts, otherwise reject. So we can decide REPAIR in O(n2) space. Membership in PSPACE gives an upper bound on the computational complexity, but does not show that the problem is hard. In particular, just because this “looks like” some PSPACE-complete problems, we cannot conclude anything other than the fact that it can be solved in polynomial space, given what we have said above. One should be very cautious about drawing stronger conclusions than the results support. This is not part of the answer expected, but let’s explore this problem further. Let G = (V; E) be a graph. For a partition P = fV1;V2;:::;Vrg of the vertices in V , let "(P ) = jfe 2 E : e = fx; yg; x 2 Vi; y 2 Vj; i 6= jgj. (This is the number of edges that go between classes of the partition.) Now if G has two edge-disjoint spanning trees, then for every partition P having r classes, "(P ) ≥ 2r − 2. Equivalently, if there is a partition P with r classes for which "(P ) < 2r − 2, G cannot have two edge-disjoint spanning trees. If G has two edge-disjoint spanning trees, player Two should win. To see this, suppose that Two knows two edge-disjoint spanning trees T1, T2. One deletes an edge not in one of these trees. Two contracts an edge in T1. Then T2 becomes a con- nected spanning subgraph with exactly one cycle, so Two restores its second tree by leaving out one edge on the unique cycle. Again Two has two edge-disjoint spanning trees. One deletes edge e from T1. Now T1 −e has exactly two components, and because T2 remains connected, 0 0 there must be an edge e 2 T2 that connects the two components. Two contracts e after which T1 and T2 are again edge-disjoint spanning trees. One deletes edge e from T2. This is symmetric to the case just given. Eventually, Two must contract edges to reduce to a single vertex. On the other hand, if there is a partition P with r classes for which "(P ) < 2r − 2, One should win. To see this, One keeps such a partition. Then One deletes an edge between two classes of P . If Two contracts an edge not between classes of P , then P still has r classes and "(P ) < 2r − 2. If Two contracts an edge between two classes, only two classes merge and there remain r −1 classes, but two edges between classes have been lost (one deleted, one contracted) so fewer than 2(r − 1) − 2 remain between classes. Eventually, One must delete edges to separate G. A theorem of Tutte (W. T. Tutte, On the problem of decomposing a graph into n connected factors, J. London Math. Soc. 36 (1961), 221–230) and Nash-Williams (C. St. J. A. Nash-Williams, Edge-disjoint spanning trees of finite graphs, J.
Load more

Recommended publications
  • CS601 DTIME and DSPACE Lecture 5 Time and Space Functions: T, S
    CS601 DTIME and DSPACE Lecture 5 Time and Space functions: t, s : N → N+ Definition 5.1 A set A ⊆ U is in DTIME[t(n)] iff there exists a deterministic, multi-tape TM, M, and a constant c, such that, 1. A = L(M) ≡ w ∈ U M(w)=1 , and 2. ∀w ∈ U, M(w) halts within c · t(|w|) steps. Definition 5.2 A set A ⊆ U is in DSPACE[s(n)] iff there exists a deterministic, multi-tape TM, M, and a constant c, such that, 1. A = L(M), and 2. ∀w ∈ U, M(w) uses at most c · s(|w|) work-tape cells. (Input tape is “read-only” and not counted as space used.) Example: PALINDROMES ∈ DTIME[n], DSPACE[n]. In fact, PALINDROMES ∈ DSPACE[log n]. [Exercise] 1 CS601 F(DTIME) and F(DSPACE) Lecture 5 Definition 5.3 f : U → U is in F (DTIME[t(n)]) iff there exists a deterministic, multi-tape TM, M, and a constant c, such that, 1. f = M(·); 2. ∀w ∈ U, M(w) halts within c · t(|w|) steps; 3. |f(w)|≤|w|O(1), i.e., f is polynomially bounded. Definition 5.4 f : U → U is in F (DSPACE[s(n)]) iff there exists a deterministic, multi-tape TM, M, and a constant c, such that, 1. f = M(·); 2. ∀w ∈ U, M(w) uses at most c · s(|w|) work-tape cells; 3. |f(w)|≤|w|O(1), i.e., f is polynomially bounded. (Input tape is “read-only”; Output tape is “write-only”.
    [Show full text]
  • EXPSPACE-Hardness of Behavioural Equivalences of Succinct One
    EXPSPACE-hardness of behavioural equivalences of succinct one-counter nets Petr Janˇcar1 Petr Osiˇcka1 Zdenˇek Sawa2 1Dept of Comp. Sci., Faculty of Science, Palack´yUniv. Olomouc, Czech Rep. [email protected], [email protected] 2Dept of Comp. Sci., FEI, Techn. Univ. Ostrava, Czech Rep. [email protected] Abstract We note that the remarkable EXPSPACE-hardness result in [G¨oller, Haase, Ouaknine, Worrell, ICALP 2010] ([GHOW10] for short) allows us to answer an open complexity ques- tion for simulation preorder of succinct one counter nets (i.e., one counter automata with no zero tests where counter increments and decrements are integers written in binary). This problem, as well as bisimulation equivalence, turn out to be EXPSPACE-complete. The technique of [GHOW10] was referred to by Hunter [RP 2015] for deriving EXPSPACE-hardness of reachability games on succinct one-counter nets. We first give a direct self-contained EXPSPACE-hardness proof for such reachability games (by adjust- ing a known PSPACE-hardness proof for emptiness of alternating finite automata with one-letter alphabet); then we reduce reachability games to (bi)simulation games by using a standard “defender-choice” technique. 1 Introduction arXiv:1801.01073v1 [cs.LO] 3 Jan 2018 We concentrate on our contribution, without giving a broader overview of the area here. A remarkable result by G¨oller, Haase, Ouaknine, Worrell [2] shows that model checking a fixed CTL formula on succinct one-counter automata (where counter increments and decre- ments are integers written in binary) is EXPSPACE-hard. Their proof is interesting and nontrivial, and uses two involved results from complexity theory.
    [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]
  • Computational Complexity: a Modern Approach
    i Computational Complexity: A Modern Approach Draft of a book: Dated January 2007 Comments welcome! Sanjeev Arora and Boaz Barak Princeton University [email protected] Not to be reproduced or distributed without the authors’ permission This is an Internet draft. Some chapters are more finished than others. References and attributions are very preliminary and we apologize in advance for any omissions (but hope you will nevertheless point them out to us). Please send us bugs, typos, missing references or general comments to [email protected] — Thank You!! DRAFT ii DRAFT Chapter 9 Complexity of counting “It is an empirical fact that for many combinatorial problems the detection of the existence of a solution is easy, yet no computationally efficient method is known for counting their number.... for a variety of problems this phenomenon can be explained.” L. Valiant 1979 The class NP captures the difficulty of finding certificates. However, in many contexts, one is interested not just in a single certificate, but actually counting the number of certificates. This chapter studies #P, (pronounced “sharp p”), a complexity class that captures this notion. Counting problems arise in diverse fields, often in situations having to do with estimations of probability. Examples include statistical estimation, statistical physics, network design, and more. Counting problems are also studied in a field of mathematics called enumerative combinatorics, which tries to obtain closed-form mathematical expressions for counting problems. To give an example, in the 19th century Kirchoff showed how to count the number of spanning trees in a graph using a simple determinant computation. Results in this chapter will show that for many natural counting problems, such efficiently computable expressions are unlikely to exist.
    [Show full text]
  • Notes on Space Complexity of Integration of Computable Real
    Notes on space complexity of integration of computable real functions in Ko–Friedman model Sergey V. Yakhontov Abstract x In the present paper it is shown that real function g(x)= 0 f(t)dt is a linear-space computable real function on interval [0, 1] if f is a linear-space computable C2[0, 1] real function on interval R [0, 1], and this result does not depend on any open question in the computational complexity theory. The time complexity of computable real functions and integration of computable real functions is considered in the context of Ko–Friedman model which is based on the notion of Cauchy functions computable by Turing machines. 1 2 In addition, a real computable function f is given such that 0 f ∈ FDSPACE(n )C[a,b] but 1 f∈ / FP if FP 6= #P. 0 C[a,b] R RKeywords: Computable real functions, Cauchy function representation, polynomial-time com- putable real functions, linear-space computable real functions, C2[0, 1] real functions, integration of computable real functions. Contents 1 Introduction 1 1.1 CF computablerealnumbersandfunctions . ...... 2 1.2 Integration of FP computablerealfunctions. 2 2 Upper bound of the time complexity of integration 3 2 3 Function from FDSPACE(n )C[a,b] that not in FPC[a,b] if FP 6= #P 4 4 Conclusion 4 arXiv:1408.2364v3 [cs.CC] 17 Nov 2014 1 Introduction In the present paper, we consider computable real numbers and functions that are represented by Cauchy functions computable by Turing machines [1]. Main results regarding computable real numbers and functions can be found in [1–4]; main results regarding computational complexity of computations on Turing machines can be found in [5].
    [Show full text]
  • Lecture 10: Space Complexity III
    Space Complexity Classes: NL and L Reductions NL-completeness The Relation between NL and coNL A Relation Among the Complexity Classes Lecture 10: Space Complexity III Arijit Bishnu 27.03.2010 Space Complexity Classes: NL and L Reductions NL-completeness The Relation between NL and coNL A Relation Among the Complexity Classes Outline 1 Space Complexity Classes: NL and L 2 Reductions 3 NL-completeness 4 The Relation between NL and coNL 5 A Relation Among the Complexity Classes Space Complexity Classes: NL and L Reductions NL-completeness The Relation between NL and coNL A Relation Among the Complexity Classes Outline 1 Space Complexity Classes: NL and L 2 Reductions 3 NL-completeness 4 The Relation between NL and coNL 5 A Relation Among the Complexity Classes Definition for Recapitulation S c NPSPACE = c>0 NSPACE(n ). The class NPSPACE is an analog of the class NP. Definition L = SPACE(log n). Definition NL = NSPACE(log n). Space Complexity Classes: NL and L Reductions NL-completeness The Relation between NL and coNL A Relation Among the Complexity Classes Space Complexity Classes Definition for Recapitulation S c PSPACE = c>0 SPACE(n ). The class PSPACE is an analog of the class P. Definition L = SPACE(log n). Definition NL = NSPACE(log n). Space Complexity Classes: NL and L Reductions NL-completeness The Relation between NL and coNL A Relation Among the Complexity Classes Space Complexity Classes Definition for Recapitulation S c PSPACE = c>0 SPACE(n ). The class PSPACE is an analog of the class P. Definition for Recapitulation S c NPSPACE = c>0 NSPACE(n ).
    [Show full text]
  • Glossary of Complexity Classes
    App endix A Glossary of Complexity Classes Summary This glossary includes selfcontained denitions of most complexity classes mentioned in the b o ok Needless to say the glossary oers a very minimal discussion of these classes and the reader is re ferred to the main text for further discussion The items are organized by topics rather than by alphab etic order Sp ecically the glossary is partitioned into two parts dealing separately with complexity classes that are dened in terms of algorithms and their resources ie time and space complexity of Turing machines and complexity classes de ned in terms of nonuniform circuits and referring to their size and depth The algorithmic classes include timecomplexity based classes such as P NP coNP BPP RP coRP PH E EXP and NEXP and the space complexity classes L NL RL and P S P AC E The non k uniform classes include the circuit classes P p oly as well as NC and k AC Denitions and basic results regarding many other complexity classes are available at the constantly evolving Complexity Zoo A Preliminaries Complexity classes are sets of computational problems where each class contains problems that can b e solved with sp ecic computational resources To dene a complexity class one sp ecies a mo del of computation a complexity measure like time or space which is always measured as a function of the input length and a b ound on the complexity of problems in the class We follow the tradition of fo cusing on decision problems but refer to these problems using the terminology of promise problems
    [Show full text]
  • User's Guide for Complexity: a LATEX Package, Version 0.80
    User’s Guide for complexity: a LATEX package, Version 0.80 Chris Bourke April 12, 2007 Contents 1 Introduction 2 1.1 What is complexity? ......................... 2 1.2 Why a complexity package? ..................... 2 2 Installation 2 3 Package Options 3 3.1 Mode Options .............................. 3 3.2 Font Options .............................. 4 3.2.1 The small Option ....................... 4 4 Using the Package 6 4.1 Overridden Commands ......................... 6 4.2 Special Commands ........................... 6 4.3 Function Commands .......................... 6 4.4 Language Commands .......................... 7 4.5 Complete List of Class Commands .................. 8 5 Customization 15 5.1 Class Commands ............................ 15 1 5.2 Language Commands .......................... 16 5.3 Function Commands .......................... 17 6 Extended Example 17 7 Feedback 18 7.1 Acknowledgements ........................... 19 1 Introduction 1.1 What is complexity? complexity is a LATEX package that typesets computational complexity classes such as P (deterministic polynomial time) and NP (nondeterministic polynomial time) as well as sets (languages) such as SAT (satisfiability). In all, over 350 commands are defined for helping you to typeset Computational Complexity con- structs. 1.2 Why a complexity package? A better question is why not? Complexity theory is a more recent, though mature area of Theoretical Computer Science. Each researcher seems to have his or her own preferences as to how to typeset Complexity Classes and has built up their own personal LATEX commands file. This can be frustrating, to say the least, when it comes to collaborations or when one has to go through an entire series of files changing commands for compatibility or to get exactly the look they want (or what may be required).
    [Show full text]
  • Probabilistic Proof Systems: a Primer
    Probabilistic Proof Systems: A Primer Oded Goldreich Department of Computer Science and Applied Mathematics Weizmann Institute of Science, Rehovot, Israel. June 30, 2008 Contents Preface 1 Conventions and Organization 3 1 Interactive Proof Systems 4 1.1 Motivation and Perspective ::::::::::::::::::::::: 4 1.1.1 A static object versus an interactive process :::::::::: 5 1.1.2 Prover and Veri¯er :::::::::::::::::::::::: 6 1.1.3 Completeness and Soundness :::::::::::::::::: 6 1.2 De¯nition ::::::::::::::::::::::::::::::::: 7 1.3 The Power of Interactive Proofs ::::::::::::::::::::: 9 1.3.1 A simple example :::::::::::::::::::::::: 9 1.3.2 The full power of interactive proofs ::::::::::::::: 11 1.4 Variants and ¯ner structure: an overview ::::::::::::::: 16 1.4.1 Arthur-Merlin games a.k.a public-coin proof systems ::::: 16 1.4.2 Interactive proof systems with two-sided error ::::::::: 16 1.4.3 A hierarchy of interactive proof systems :::::::::::: 17 1.4.4 Something completely di®erent ::::::::::::::::: 18 1.5 On computationally bounded provers: an overview :::::::::: 18 1.5.1 How powerful should the prover be? :::::::::::::: 19 1.5.2 Computational Soundness :::::::::::::::::::: 20 2 Zero-Knowledge Proof Systems 22 2.1 De¯nitional Issues :::::::::::::::::::::::::::: 23 2.1.1 A wider perspective: the simulation paradigm ::::::::: 23 2.1.2 The basic de¯nitions ::::::::::::::::::::::: 24 2.2 The Power of Zero-Knowledge :::::::::::::::::::::: 26 2.2.1 A simple example :::::::::::::::::::::::: 26 2.2.2 The full power of zero-knowledge proofs ::::::::::::
    [Show full text]
  • A Short History of Computational Complexity
    The Computational Complexity Column by Lance FORTNOW NEC Laboratories America 4 Independence Way, Princeton, NJ 08540, USA [email protected] http://www.neci.nj.nec.com/homepages/fortnow/beatcs Every third year the Conference on Computational Complexity is held in Europe and this summer the University of Aarhus (Denmark) will host the meeting July 7-10. More details at the conference web page http://www.computationalcomplexity.org This month we present a historical view of computational complexity written by Steve Homer and myself. This is a preliminary version of a chapter to be included in an upcoming North-Holland Handbook of the History of Mathematical Logic edited by Dirk van Dalen, John Dawson and Aki Kanamori. A Short History of Computational Complexity Lance Fortnow1 Steve Homer2 NEC Research Institute Computer Science Department 4 Independence Way Boston University Princeton, NJ 08540 111 Cummington Street Boston, MA 02215 1 Introduction It all started with a machine. In 1936, Turing developed his theoretical com- putational model. He based his model on how he perceived mathematicians think. As digital computers were developed in the 40's and 50's, the Turing machine proved itself as the right theoretical model for computation. Quickly though we discovered that the basic Turing machine model fails to account for the amount of time or memory needed by a computer, a critical issue today but even more so in those early days of computing. The key idea to measure time and space as a function of the length of the input came in the early 1960's by Hartmanis and Stearns.
    [Show full text]
  • 26 Space Complexity
    CS:4330 Theory of Computation Spring 2018 Computability Theory Space Complexity Haniel Barbosa Readings for this lecture Chapter 8 of [Sipser 1996], 3rd edition. Sections 8.1, 8.2, and 8.3. Space Complexity B We now consider the complexity of computational problems in terms of the amount of space, or memory, they require B Time and space are two of the most important considerations when we seek practical solutions to most problems B Space complexity shares many of the features of time complexity B It serves a further way of classifying problems according to their computational difficulty 1 / 22 Space Complexity Definition Let M be a deterministic Turing machine, DTM, that halts on all inputs. The space complexity of M is the function f : N ! N, where f (n) is the maximum number of tape cells that M scans on any input of length n. Definition If M is a nondeterministic Turing machine, NTM, wherein all branches of its computation halt on all inputs, we define the space complexity of M, f (n), to be the maximum number of tape cells that M scans on any branch of its computation for any input of length n. 2 / 22 Estimation of space complexity Let f : N ! N be a function. The space complexity classes, SPACE(f (n)) and NSPACE(f (n)), are defined by: B SPACE(f (n)) = fL j L is a language decided by an O(f (n)) space DTMg B NSPACE(f (n)) = fL j L is a language decided by an O(f (n)) space NTMg 3 / 22 Example SAT can be solved with the linear space algorithm M1: M1 =“On input h'i, where ' is a Boolean formula: 1.
    [Show full text]
  • The Complexity Class NP
    Quantum Many-Body Systems Boulder School Ashwin Nayak (U. Waterloo & Perimeter) July 22, 2010 Quantum Complexity Theory II In the last lecture, we saw what it means to compute a function efficiently, and saw subproblems of ISING GROUND STATE and k-SAT for which we know efficient algorithms. We also saw that the best known algorithms or these problems in their full generality are not efficient, and in fact are not qualitatively better than taking a brute-force search approach. Today, we’ll develop a theory that explains to some extent the difficulty in designing efficient algorithms for these problems. The complexity class NP Let us revisit the language ISING GROUND STATE. If someone gave us a state σ claiming that it had en- ergy H(σ) at most the required threshold k, we would be able to efficiently check whether that is true. In fact, whenever an instance (G,c,b,k) is in the language, there is such a state—the ground state would be one such. When the instance is not in the language, there is no such state, and any claimed state can efficiently be checked and rejected. The problem k-SAT enjoys the same property. If we are presented with an assignment, and we can check efficiently whether it satisfies the given formula or not. By definition, whenever the formula is satisfiable, there is evidence supporting this (e.g., a satisfying assignment), and when the formula is not satisfiable any claimed evidence (like a putative satisfying assignment) can be checked and rejected efficiently. This property is common to a wide array of problems, including the travelling salesman problem, graph isomorphism, scheduling with constraints, etc., and is the defining characteristic of the complexity class NP.
    [Show full text]