DOCSLIB.ORG

Time Complexity

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Time Complexity Time Complexity [Turing] has for the first time succeeded in giving an absolute definition ofan interesting epistemological notion, i.e., one not depending on the formalism chosen. – Kurt Gödel [Turing machines have] the advantage of making the identification with effectiveness in the ordinary (not explicitly defined) sense evident immediately. – Alonzo Church Computational Complexity, by Fu Yuxi Time Complexity 1 / 80 Synopsis 1. Turing Machine 2. Universal Turing Machine 3. Speedup Theorem 4. Time Complexity Class 5. Verification Problem 6. Time Hierarchy Theorem 7. Gap Theorem Computational Complexity, by Fu Yuxi Time Complexity 2 / 80 Turing Machine Computational Complexity, by Fu Yuxi Time Complexity 3 / 80 k-Tape Turing Machine A k-tape Turing Machine M has k-tapes. I The first tape is the read-only input tape. I The other k − 1 tapes are the read-write work tapes. I the k-th tape is also used as the output tape. 0 1 0 1 1 1 1 0 1 0 ··· q8 0 1 0 1 1 1 1 0 1 0 ··· ··· Computational Complexity, by Fu Yuxi Time Complexity 4 / 80 k-Tape Turing Machine A k-tape Turing Machine is described by a tuple (Γ; Q; δ). 1. A finite set Γ of symbol, called alphabet such that Γ ⊇ f0; 1; □; Bg. 2. A finite set Q of states such that Q ⊇ fqstart; qhaltg. 3. A transition function δ : Q × Γk ! Q × Γk−1 × fL; S; Rgk. 0 1 0 1 1 1 1 0 1 0 ··· q8 0 1 0 1 1 1 1 0 1 0 ··· ··· Computational Complexity, by Fu Yuxi Time Complexity 5 / 80 Configuration and Computation A configuration of a running TM M consists of the following: I the state; I the contents of the work tapes; I the head positions. initial/start configuration, final configuration; 1-step computation 0 1 0 1 1 1 1 0 1 0 ··· q8 0 1 0 1 1 1 1 0 1 0 ··· ··· Computational Complexity, by Fu Yuxi Time Complexity 6 / 80 Problems Solvable by Turing Machines A function f : f0; 1g∗ ! f0; 1g∗ is a problem. I M computes or solves f if M(x) = f(x) for every x 2 f0; 1g∗. I “M(x) = y” stands for “M halts with y written on its output tape if its input tape is preloaded with x”. A function d : f0; 1g∗ ! f0; 1g is a decision problem. I M decides d if M computes d. A set L ⊆ f0; 1g∗ is a language. 1; if x 2 L; I M accepts L if M decides the characteristic function L(x) = 0; if x 2= L: Computational Complexity, by Fu Yuxi Time Complexity 7 / 80 A 2-Tape Turing Machine for Palindrome Problem hqs; B; □i ! hqc; B; R; Ri hqc; 0; □i ! hqc; 0; R; Ri hqc; 1; □i ! hqc; 1; R; Ri hqc; □; □i ! hql; □; L; Si hql; 0; □i ! hql; □; L; Si hql; 1; □i ! hql; □; L; Si hql; B; □i ! hqt; □; R; Li hqt; 0; 0i ! hqt; □; R; Li hqt; 1; 1i ! hqt; □; R; Li hqt; □; Bi ! hqy; 1; S; Si hqt; 0; 1i ! hqn; □; S; Li hqt; 1; 0i ! hqn; □; S; Li hqn; 0; 0i ! hqn; □; S; Li hqn; 0; 1i ! hqn; □; S; Li hqn; 1; 0i ! hqn; □; S; Li hqn; 1; 1i ! hqn; □; S; Li hqn; 0; Bi ! hqn; B; S; Ri hqn; 1; Bi ! hqn; B; S; Ri hqn; 0; □i ! hqn; 0; S; Si hqn; 1; □i ! hqn; 0; S; Si Computational Complexity, by Fu Yuxi Time Complexity 8 / 80 Time Function Suppose T : N ! N and M computes the problem f. We say that M computes f in T(n)-time if its computation on every input x requires at most T(jxj) steps. I jxj denotes the length of x. I For example j21024 − 1j = 1024. We shall assume that all time functions ≥ n. Computational Complexity, by Fu Yuxi Time Complexity 9 / 80 Design Turing Machines for the following functions: 1. s(x) = x + 1. [using a TM for s(x) we can implement counter.] x 2. u(x) = 1 . [we often attach 1x to disallow a TM to run more than x steps.] x 3. e(x) = 2 . [the machine simply outputs 10x.] 4. l(x) = log(x). [if x = 2k, the machine outputs jxj + 1; otherwise it outputs jxj.] Computational Complexity, by Fu Yuxi Time Complexity 10 / 80 Time Constructible Function Suppose T : N ! N and T(n) ≥ n. 1. T is time constructible if there is a Turing Machine that computes the function 1n 7! xT(n)y in time O(T(n)). 2. T is fully time constructible if there is a Turing Machine that upon receiving 1n stops in exactly T(n)-steps. We shall only care about the time-constructible functions. Computational Complexity, by Fu Yuxi Time Complexity 11 / 80 Hard-Wiring a Clock to a Turing Machine Let M = (Q0; Γ0; !0) be a k0-tape TM. Let T = (Q1; Γ1; !1) be a k1-tape TM that runs in T(n)-steps. We can use T as a timer to force M to terminate in no more than T(n)-steps. I The integrated (k0+k1)-tape TM consists of two parallel machines. After replicating the input, it operates as the TM specified by I 1 0 Q = Q0 × Q1 and (q; q ) = qhalt for q 2 Q0 and (q ; q) = qhalt for q 2 Q1; I halt halt Γ = Γ0 × Γ1; I ! = !0 × !1. T is said to be hard-wired to M. Computational Complexity, by Fu Yuxi Time Complexity 12 / 80 Complexity theory ought to be model independent. Variants of Turing Machines are equivalent to the k-tape Turing Machines in the sense that they can simulate each other with polynomial overhead. Computational Complexity, by Fu Yuxi Time Complexity 13 / 80 Oblivious Turing Machine A TM is oblivious if the locations of its heads at the i-th step of the execution on input x depend only on jxj and i. Computational Complexity, by Fu Yuxi Time Complexity 14 / 80 Church-Turing Thesis. Every physically realizable computing device can be simulated by a Turing Machine. Law of Nature vs Wisdom of Human. Computational Complexity, by Fu Yuxi Time Complexity 15 / 80 Universal Turing Machine Computational Complexity, by Fu Yuxi Time Complexity 16 / 80 The confusion of software, hardware and datum lies at the heart of computation theory. ∗ I Finite syntactic objects can be coded up by numbers. [(101) .] Computational Complexity, by Fu Yuxi Time Complexity 17 / 80 Turing Machine as String 1. A transition (p; a; b; c) ! (q; d; e; R; S; L) can be coded up by say 001y1010y1100y0000yy011y1111y0000y01y00y10: 2. A transition table can be coded up by a string of the form z _ z ::: z _ z: (1) 3. A binary representation of (1) is obtained by using the following map: 0 7! 01; 1 7! 10; y 7! 00; z 7! 11: Computational Complexity, by Fu Yuxi Time Complexity 18 / 80 Turing Machine as String The encodings can be made to enjoy the following property: 1. Every TM is represented by infinitely many strings in f0; 1g∗. I If σ encodes a machine, then 0iσ0j encodes the same machine. 2. Every string in f0; 1g∗ represents some TM. I Let all illegal strings code up a specific TM. I Let xMy be the binary representation of TM M. I Let Mα be the TM represented by the string α. Computational Complexity, by Fu Yuxi Time Complexity 19 / 80 Effective Enumeration of Turing Machine By fixing an effective bijection from f0; 1g∗ to N, the set of natural numbers, we obtain M0; M1;:::; Mi;:::: The functions defined by these machines are normally denoted by ϕ0; ϕ1; : : : ; ϕi;:::: Computational Complexity, by Fu Yuxi Time Complexity 20 / 80 Universal Turing Machine and Efficient Simulation Theorem. There is a universal TM U that renders true the following statements. ∗ 1. U(x; α) ' Mα(x) for all x; α 2 f0; 1g . [this is Turing’s universal machine] 2. If Mα(x) halts in T(jxj) steps, then U(x; α) halts in cT(jxj) log T(jxj) steps, where c is a polynomial of α. [c is independent of jxj.] I The version with O(T(n)) time amplification appeared in 1965. I The present version was published in 1966. 1. J. Hartmanis and R. Stearns. On the Computational Complexity of Algorithms. Transactions of AMS, 117:285-306, 1965. 2. F. Hennie and R. Stearns. Two-Tape Simulation of Multitape Turing Machines. Journal of ACM, 13:533-546, 1966. Computational Complexity, by Fu Yuxi Time Complexity 21 / 80 Proof of Hennie and Stearns A universal TM has a fixed number of work tapes. How does it deal with a source TM with an unknown number of work tapes? The solution is to use two work tapes: I The main tape simulates all the work tapes of the source TM. I The scratch tape is used to record current state, to indicate zone boundaries, and to speed up shifting. Computational Complexity, by Fu Yuxi Time Complexity 22 / 80 Proof of Hennie and Stearns From three bidirectional worktapes to one bidirectional worktape f i r s t w o r k t a p e s e c o n d w o r k t a p t h i r d w o r k t a p e L2 L1 L0 0 R0 R1 R2 Imagine that the head is fixed and the tapes are shifting in opposite direction. One may perceive that a symbol stored in the main tape of U is a tuple, say (k; r; o).
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]
  • The Complexity of Space Bounded Interactive Proof Systems
    The Complexity of Space Bounded Interactive Proof Systems ANNE CONDON Computer Science Department, University of Wisconsin-Madison 1 INTRODUCTION Some of the most exciting developments in complexity theory in recent years concern the complexity of interactive proof systems, defined by Goldwasser, Micali and Rackoff (1985) and independently by Babai (1985). In this paper, we survey results on the complexity of space bounded interactive proof systems and their applications. An early motivation for the study of interactive proof systems was to extend the notion of NP as the class of problems with efficient \proofs of membership". Informally, a prover can convince a verifier in polynomial time that a string is in an NP language, by presenting a witness of that fact to the verifier. Suppose that the power of the verifier is extended so that it can flip coins and can interact with the prover during the course of a proof. In this way, a verifier can gather statistical evidence that an input is in a language. As we will see, the interactive proof system model precisely captures this in- teraction between a prover P and a verifier V . In the model, the computation of V is probabilistic, but is typically restricted in time or space. A language is accepted by the interactive proof system if, for all inputs in the language, V accepts with high probability, based on the communication with the \honest" prover P . However, on inputs not in the language, V rejects with high prob- ability, even when communicating with a \dishonest" prover. In the general model, V can keep its coin flips secret from the prover.
    [Show full text]
  • Lecture 14 (Feb 28): Probabilistically Checkable Proofs (PCP) 14.1 Motivation: Some Problems and Their Approximation Algorithms
    CMPUT 675: Computational Complexity Theory Winter 2019 Lecture 14 (Feb 28): Probabilistically Checkable Proofs (PCP) Lecturer: Zachary Friggstad Scribe: Haozhou Pang 14.1 Motivation: Some problems and their approximation algorithms Many optimization problems are NP-hard, and therefore it is unlikely to efficiently find optimal solutions. However, in some situations, finding a provably good-enough solution (approximation of the optimal) is also acceptable. We say an algorithm is an α-approximation algorithm for an optimization problem iff for every instance of the problem it can find a solution whose cost is a factor of α of the optimum solution cost. Here are some selected problems and their approximation algorithms: Example: Min Vertex Cover is the problem that given a graph G = (V; E), the goal is to find a vertex cover C ⊆ V of minimum size. The following algorithm gives a 2-approximation for Min Vertex Cover: Algorithm 1 Min Vertex Cover Algorithm Input: Graph G = (V; E) Output: a vertex cover C of G. C ; while some edge (u; v) has u; v2 = C do C C [ fu; vg end while return C Claim 1 Let C∗ be an optimal solution, the returned solution C satisfies jCj ≤ 2jC∗j. Proof. Let M be the edges considered by the algorithm in the loop, we have jCj = 2jMj. Also, jC∗j covers M and no two edges in M share an endpoint (M is a matching), so jC∗j ≥ jMj. Therefore, jCj = 2jMj ≤ 2jC∗j. Example: Max SAT is the problem that given a CNF formula, the goal is to find a assignment that satisfies as many clauses as possible.
    [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]
  • Introduction to Complexity Theory Big O Notation Review Linear Function: R(N)=O(N)
    GS019 - Lecture 1 on Complexity Theory Jarod Alper (jalper) Introduction to Complexity Theory Big O Notation Review Linear function: r(n)=O(n). Polynomial function: r(n)=2O(1) Exponential function: r(n)=2nO(1) Logarithmic function: r(n)=O(log n) Poly-log function: r(n)=logO(1) n Definition 1 (TIME) Let t : . Define the time complexity class, TIME(t(n)) to be ℵ−→ℵ TIME(t(n)) = L DTM M which decides L in time O(t(n)) . { |∃ } Definition 2 (NTIME) Let t : . Define the time complexity class, NTIME(t(n)) to be ℵ−→ℵ NTIME(t(n)) = L NDTM M which decides L in time O(t(n)) . { |∃ } Example 1 Consider the language A = 0k1k k 0 . { | ≥ } Is A TIME(n2)? Is A ∈ TIME(n log n)? Is A ∈ TIME(n)? Could∈ we potentially place A in a smaller complexity class if we consider other computational models? Theorem 1 If t(n) n, then every t(n) time multitape Turing machine has an equivalent O(t2(n)) time single-tape turing≥ machine. Proof: see Theorem 7:8 in Sipser (pg. 232) Theorem 2 If t(n) n, then every t(n) time RAM machine has an equivalent O(t3(n)) time multi-tape turing machine.≥ Proof: optional exercise Conclusion: Linear time is model specific; polynomical time is model indepedent. Definition 3 (The Class P ) k P = [ TIME(n ) k Definition 4 (The Class NP) GS019 - Lecture 1 on Complexity Theory Jarod Alper (jalper) k NP = [ NTIME(n ) k Equivalent Definition of NP NP = L L has a polynomial time verifier .
    [Show full text]
  • Circuit Lower Bounds for Merlin-Arthur Classes
    Electronic Colloquium on Computational Complexity, Report No. 5 (2007) Circuit Lower Bounds for Merlin-Arthur Classes Rahul Santhanam Simon Fraser University [email protected] January 16, 2007 Abstract We show that for each k > 0, MA/1 (MA with 1 bit of advice) doesn’t have circuits of size nk. This implies the first superlinear circuit lower bounds for the promise versions of the classes MA AM ZPPNP , and k . We extend our main result in several ways. For each k, we give an explicit language in (MA ∩ coMA)/1 which doesn’t have circuits of size nk. We also adapt our lower bound to the average-case setting, i.e., we show that MA/1 cannot be solved on more than 1/2+1/nk fraction of inputs of length n by circuits of size nk. Furthermore, we prove that MA does not have arithmetic circuits of size nk for any k. As a corollary to our main result, we obtain that derandomization of MA with O(1) advice implies the existence of pseudo-random generators computable using O(1) bits of advice. 1 Introduction Proving circuit lower bounds within uniform complexity classes is one of the most fundamental and challenging tasks in complexity theory. Apart from clarifying our understanding of the power of non-uniformity, circuit lower bounds have direct relevance to some longstanding open questions. Proving super-polynomial circuit lower bounds for NP would separate P from NP. The weaker result that for each k there is a language in NP which doesn’t have circuits of size nk would separate BPP from NEXP, thus answering an important question in the theory of derandomization.
    [Show full text]
  • Introduction to Complexity Classes
    Introduction to Complexity Classes Marcin Sydow Introduction to Complexity Classes Marcin Sydow Introduction Denition to Complexity Classes TIME(f(n)) TIME(f(n)) denotes the set of languages decided by Marcin deterministic TM of TIME complexity f(n) Sydow Denition SPACE(f(n)) denotes the set of languages decided by deterministic TM of SPACE complexity f(n) Denition NTIME(f(n)) denotes the set of languages decided by non-deterministic TM of TIME complexity f(n) Denition NSPACE(f(n)) denotes the set of languages decided by non-deterministic TM of SPACE complexity f(n) Linear Speedup Theorem Introduction to Complexity Classes Marcin Sydow Theorem If L is recognised by machine M in time complexity f(n) then it can be recognised by a machine M' in time complexity f 0(n) = f (n) + (1 + )n, where > 0. Blum's theorem Introduction to Complexity Classes Marcin Sydow There exists a language for which there is no fastest algorithm! (Blum - a Turing Award laureate, 1995) Theorem There exists a language L such that if it is accepted by TM of time complexity f(n) then it is also accepted by some TM in time complexity log(f (n)). Basic complexity classes Introduction to Complexity Classes Marcin (the functions are asymptotic) Sydow P S TIME nj , the class of languages decided in = j>0 ( ) deterministic polynomial time NP S NTIME nj , the class of languages decided in = j>0 ( ) non-deterministic polynomial time EXP S TIME 2nj , the class of languages decided in = j>0 ( ) deterministic exponential time NEXP S NTIME 2nj , the class of languages decided
    [Show full text]
  • Computational Complexity
    Computational complexity Plan Complexity of a computation. Complexity classes DTIME(T (n)). Relations between complexity classes. Complete problems. Domino problems. NP-completeness. Complete problems for other classes Alternating machines. – p.1/17 Complexity of a computation A machine M is T (n) time bounded if for every n and word w of size n, every computation of M has length at most T (n). A machine M is S(n) space bounded if for every n and word w of size n, every computation of M uses at most S(n) cells of the working tape. Fact: If M is time or space bounded then L(M) is recursive. If L is recursive then there is a time and space bounded machine recognizing L. DTIME(T (n)) = fL(M) : M is det. and T (n) time boundedg NTIME(T (n)) = fL(M) : M is T (n) time boundedg DSPACE(S(n)) = fL(M) : M is det. and S(n) space boundedg NSPACE(S(n)) = fL(M) : M is S(n) space boundedg . – p.2/17 Hierarchy theorems A function S(n) is space constructible iff there is S(n)-bounded machine that given w writes aS(jwj) on the tape and stops. A function T (n) is time constructible iff there is a machine that on a word of size n makes exactly T (n) steps. Thm: Let S2(n) be a space-constructible function and let S1(n) ≥ log(n). If S1(n) lim infn!1 = 0 S2(n) then DSPACE(S2(n)) − DSPACE(S1(n)) is nonempty. Thm: Let T2(n) be a time-constructible function and let T1(n) log(T1(n)) lim infn!1 = 0 T2(n) then DTIME(T2(n)) − DTIME(T1(n)) is nonempty.
    [Show full text]
  • DTIME, NTIME, DSPACE, Measured on Multi-Tape Turing Machines. Th
    CMPSCI 601: Recall From Last Time Lecture 9 Def: DTIME, NTIME, DSPACE, measured on Multi-tape Turing Machines. ¡¤£¥§ © £¡¤£¥§§© Th: DTIME ¢¡¤£¦¥¨§ © RAM-TIME DTIME ¥© L DSPACE + ¥! #"%$'&(© ¥ © ) * P DTIME +-, DTIME $ + #"%$'& ¥ © ¥ © * ) NP NTIME +-, NTIME $ + ¥! ."/$ &0© ¢¥ © ) * PSPACE DSPACE +-, DSPACE $ ¥43657£¦¥§81 ¥ Th: For ¡¤£¥§21 , ¢¡¤£¦¥§:© ¡9£¦¥§ © DTIME ¡9£¦¥§ © NTIME DSPACE #">"@?9&%& =< © DSPACE ;57£¦¥§:© DTIME Cor: L P NP PSPACE 1 CMPSCI 601: NTIME and NP Lecture 9 ¢¡¤£¦¥¨§ © £¦¡¤£¦¥§§ NTIME probs. accepted by NTMs in time + ."/$ & ¢¥ © ¥ © ) * NP NTIME +-, NTIME $ Theorem 9.1 For any function ¡¤£¦¥§ , ¢¡¤£¦¥§:© ¡9£¦¥§ © DTIME ¡9£¦¥§ © NTIME DSPACE Proof: The first inclusion is obvious. For the second, £¡¤£¥§§ note that in space we can simulate all computa- £¡¤£¦¥¨§§ tions of length , so we will find the shortest ac- cepting one if it exists. ¡ =< #"£¢ " ?9&%&(© Recall: DSPACE ¡¤£¥§ © DTIME Corollary 9.2 L P NP PSPACE 2 So we can simulate NTM’s by DTM’s, at the cost of an exponential increase in the running time. It may be pos- sible to improve this simulation, though no essentially better one is known. If the cost could be reduced to poly- nomial, we would have that P NP. There is probably such a quantitative difference between the power of NTM’s and DTM’s. But note that qualita- tively there is no difference. If ¡ is the language of some NTM ¢ , it must also be r.e. because there is a DTM that £ searches through all computations of ¢ on , first of one ¡ ¤ ¥ step, then of two steps, and so on. If £ , will eventually find an accepting computation. If not, it will search forever. What about an NTM-based definition of “recursive” or “Turing-decidable” sets? This is less clear because NTM’s don’t decide – they just have a range of possible actions.
    [Show full text]
  • Lecture 1: Introduction
    princeton university cos 522: computational complexity Lecture 1: Introduction Lecturer: Sanjeev Arora Scribe:Scribename The central problem of computational complexity theory is : how efficiently can we solve a specific computational problem on a given computational model? Of course, the model ultimately of interest is the Turing machine (TM), or equivalently, any modern programming language such as C or Java. However, while trying to understand complexity issues arising in the study of the Turing machine, we often gain interesting insight by considering modifications of the basic Turing machine —nondeterministic, alternating and probabilistic TMs, circuits, quantum TMs etc.— as well as totally different computational models— communication games, decision trees, algebraic computation trees etc. Many beautiful results of complexity theory concern such models and their interrela- tionships. But let us refresh our memories about complexity as defined using a multi- tape TM, and explored extensively in undergrad texts (e.g., Sipser’s excellent “Introduction to the Theory of Computation.”) We will assume that the TM uses the alphabet {0, 1}.Alanguage is a set of strings over {0, 1}. The TM is said to decide the language if it accepts every string in the language, and re- jects every other string. We use asymptotic notation in measuring the resources used by a TM. Let DTIME(t(n)) consist of every language that can be decided by a deterministic multitape TM whose running time is O(t(n)) on inputs of size n. Let NTIME(t(n)) be the class of languages that can be decided by a nondeterministic multitape TM (NDTM for short) in time O(t(n)).
    [Show full text]
  • Comparing Complexity Classes*
    JOURNAL OF COMPUTER AND SYSTEM SCIENCES 9, 213-229 (1974) Comparing Complexity Classes* RONALD V. BOOKt Center for Research in Computing Technology, Harvard University, Cambridge, Massachusetts 02138 Received January 20, 1973 Complexity classes defined by time-bounded and space-bounded Turing acceptors are studied in order to learn more about the cost of deterministic simulation of non- deterministic processes and about time-space tradeoffs. Here complexity classes are compared by means of reducibilities and class-complete sets. The classes studied are defined by bounds of the order n, n ~, 2 n, 2 n~. The results do not establish the existence of possible relationships between these classes; rather, they show the consequences of such relationships, in some cases offering circumstantial evidence that these relation- ships do not hold and that certain pairs of classes are set-theoretically incomparable. INTRODUCTION Certain long-standing open questions in automata-based complexity have resurfaced recently due to the work by Cook [9] and Karp [17] on efficient reducibilities among combinatorial problems. In particular, questions regarding time-space tradeoffs and the cost of deterministic simulation of nondeterministic machines have received renewed attention. The purpose of this paper is to study relationships between certain classes of languages accepted by time- and space-bounded Turing machines in order to learn more about these questions. The questions of time-space tradeoffs and deterministic simulation of nondeter- ministic processes can be studied on an ad hoc basis, e.g., a particular problem can be solved via a nondeterministic process and then an efficient deterministic process might be shown to realize the result.
    [Show full text]
  • How Hard Is Computing the Edit Distance?1
    Information and Computation 165, 1–13 (2001) doi:10.1006/inco.2000.2914, available online at http://www.idealibrary.com on How Hard Is Computing the Edit Distance?1 Giovanni Pighizzini Dipartimento di Scienze dell’Informazione, Universita` degli Studi di Milano, via Comelico 39, 20135 Milan, Italy E-mail: [email protected] Received October 26, 1995 The notion of edit distance arises in very different fields such as self-correcting codes, parsing theory, speech recognition, and molecular biology. The edit distance between an input string and a language L is the minimum cost of a sequence of edit operations (substitution of a symbol in another incorrect symbol, insertion of an extraneous symbol, deletion of a symbol) needed to change the input string into a sentence of L. In this paper we study the complexity of computing the edit distance, discovering sharp boundaries between classes of languages for which this function can be efficiently evaluated and classes of languages for which it seems to be difficult to compute. Our main result is a parallel algorithm for computing the edit distance for the class of languages accepted by one-way nondeterministic auxiliary pushdown automata working in polynomial time, a class that strictly contains context–free languages. Moreover, we show that this algorithm can be extended in order to find a sentence of the language from which the input string has minimum distance. C 2001 Academic Press Key Words: formal languages; computational complexity; string correction; error correction; edit distance; dynamic programming. 1 INTRODUCTION Consider a language L 6 and consider receiving as input, strings that represent instances of L, but possibly containing errors (due, for example, to faulty data entry or to noise in the communication channel).
    [Show full text]