1 / 26

CS21 Decidability and Tractability

CS21 Decidability and Tractability. Lecture 1 January 6, 2014. Outline. administrative stuff motivation and overview of the course problems and languages Finite Automata. Administrative Stuff. Text: Introduction to the Theory of Computation – 3 rd Edition by Mike Sipser

marius
Download Presentation

CS21 Decidability and Tractability

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CS21 Decidability and Tractability Lecture 1 January 6, 2014 CS21 Lecture 1

  2. Outline • administrative stuff • motivation and overview of the course • problems and languages • Finite Automata CS21 Lecture 1

  3. Administrative Stuff • Text: Introduction to the Theory of Computation – 3rd Edition by Mike Sipser • Lectures self-contained • Weekly homework • collaboration in groups of 2-3 encouraged • separate write-ups (clarity counts) • Midterm and final • indistinguishable from homework except cumulative, no collaboration allowed CS21 Lecture 1

  4. Administrative Stuff • No programming in this course • Things I assume you are familiar with: • programming and basic algorithms • asymptotic notation “big-oh” • sets, graphs • proofs, especially induction proofs CS21 Lecture 1

  5. Motivation/Overview • This course: introduction to Theory of Computation • what does it mean? • why do we care? • what will this course cover? CS21 Lecture 1

  6. Motivation/Overview Computability and Complexity Theory CS21 Lecture 1

  7. Motivation/Overview • At the heart of programs lie algorithms • To study algorithms we must be able to speak mathematically about: • computational problems • computers • algorithms CS21 Lecture 1

  8. Motivation/Overview • In a perfect world • for each problem we would have an algorithm • the algorithm would be the fastest possible (requires proof that no others are faster) What would CS look like in this world? CS21 Lecture 1

  9. Motivation/Overview • Our world (fortunately) is not so perfect: • not all problems have algorithms (we will prove this) • for many problems we know embarrassingly little about what the fastest algorithm is • multiplying two integers • factoring an integer into primes • determining shortest tour of given n cities • for certain problems, fast algorithms would change the world (we will see this) CS21 Lecture 1

  10. Motivation/Overview Part One: computational problems, models of computation, characterizations of the problems they solve, and limits on their power • Finite Automata and Regular Languages • Pushdown Automata and Context Free Grammars CS21 Lecture 1

  11. Motivation/Overview Part Two: Turing Machines, and limits on their power (undecidability), reductions between problems Part Three: complexity classes P and NP, NP-completeness, limits of efficient computation CS21 Lecture 1

  12. Main Points of Course (un)-decidability Some problems have no algorithms! (in)-tractability Many problems that we’d like to solve probably have no efficient algorithms! (no one knows how to prove this yet…) CS21 Lecture 1

  13. What is a problem? • Some examples: • given n integers, produce a sorted list • given a graph and nodes s and t, find the (first) shortest path from s to t • given an integer, find its prime factors • problem associates each input to an output • input and output are strings over a finite alphabetΣ CS21 Lecture 1

  14. What is a problem? • A problem is a function: f:Σ* → Σ* • Simple. Can we make it simpler? • Yes. Decision problems: f:Σ* → {accept, reject} • Does this still capture our notion of problem, or is it too restrictive? CS21 Lecture 1

  15. What is a problem? • Example: factoring: • given an integer m, find its prime factors ffactor:{0,1}*→{0,1}* • Decision version: • given 2 integers m,k, accept iff m has a prime factor p < k • Can use one to solve the other and vice versa. True in general (homework). CS21 Lecture 1

  16. What is a problem? • For most of this course, a problem is a decision problem: f:Σ* → {accept, reject} • Equivalent notion: language L  Σ* the set of strings that map to “accept” • Example: L = set of pairs (m,k) for which m has a prime factor p < k CS21 Lecture 1

  17. What is computation? • accept • reject • loop forever • the set of strings that lead to “accept” is the language recognized by this machine • if every other string leads to “reject”, then this language is decided by the machine input machine CS21 Lecture 1

  18. Terminology • finite alphabetΣ : a set of symbols • languageL  Σ* : subset of strings over Σ • a machine takes an input string and either • accepts, rejects, or • loops forever • a machine recognizes the set of strings that lead to accept • a machine decides a language L if it accepts x  L and rejects x  L CS21 Lecture 1

  19. What goes inside the box? • accept • reject • loop forever • We want the simplest mathematical formalization of computation possible. • Strategy: • endow box with a feature of computation • try to characterize the languages decided • identify language we “know” real computers can decide that machine cannot • add new feature to overcome limits input machine CS21 Lecture 1

  20. Finite Automata • simple model of computation • reads input from left to right, one symbol at a time • maintains state: information about what seen so far (“memory”) • finite automaton has finite # of states: cannot remember more things for longer inputs • 2 ways to describe: by diagram, or formally CS21 Lecture 1

  21. FA diagrams (single) start state alphabet Σ = {0,1} 0,1 • read input one symbol at a time; follow arrows; accept if end in accept state 1 states 0 (several) accept states transition for each symbol 0,1 CS21 Lecture 1

  22. FA operation • Example of FA operation: input: 0 1 0 1 0,1 1 not accepted 0 0,1 CS21 Lecture 1

  23. FA operation • Example of FA operation: input: 1 0 1 0,1 1 accepted What language does this FA recognize? L = {x : x  {0,1}*, x1 = 1} 0 0,1 CS21 Lecture 1

  24. Example FA 0 • What language does this FA recognize? L = {x : x  {0,1}*, x has even # of 1s} • illustrates fundamental feature/limitation of FA: • “tiny” memory • in this example only “remembers” 1 bit of info. 1 0 even odd 1 CS21 Lecture 1

  25. Example FA Σ = {A,B,C} {Q,N,D} B B A 5 10 15 rej C C A C C A B B A,B,C A,C Try: AC CBCC AA BBBBBBB CCBC A,B,C A A B B B 35 20 25 30 C A C “35 cents” CS21 Lecture 1

  26. FA formal definition A finite automaton is a 5-tuple (Q, Σ, δ, q0, F) • Q is a finite set called the states • Σ is a finite set called the alphabet • δ:Q x Σ → Q is a function called the transition function • q0 is an element of Q called the start state • F is a subset of Q called the accept states CS21 Lecture 1

More Related