Download slides from class - Cornell Computer Science

CS 381 - Summer 2005
Final class - July 1st
Assorted fun topics in computability and
complexity
One-slide summary of
381
Linguistic Formalism
Device
Reg exp
DFA
CFG
NPDA
CSG
NLBA
Recursive languages
Total TM
R. E. languages
TM
Practical uses of these
languages
• Regular expressions
– pattern matching
– lexical analysis in compilers
• CFGs
– compilers
– NLP
• Recursive languages
– everything computers do!
What happens now?
• Many more practical applications (program
analysis, databases)
– may need to design a new language; tradeoff
between expressivity of language and the
difficulty of implementing/analyzing programs
• As new computational devices are created
(e.g. cellular automata, quantum
computers), want to reason about their
power relative to TMs
What happens now? (2)
• Recursion (Computability) Theory studies
the hierarchy of languages above the r.e.
sets
– oracle TMs : suppose I could get answers to
arbitrary instances of HP "for free". What
would this allow me to compute?
– suppose I had TMs taking real numbers as
input (so inputs may be infinite). What
functions can these compute?
What happens now? (3)
• Complexity Theory studies issues that
arise when we put time or space
constraints on our computational devices
– e.g. TMs bounded to run in time or space
polynomial in the length of the input
– or other computational devices, like circuits
– The P vs NP question - most famous open
problem in all of CS.
Fun topic #1 - cellular
automata
• A computational model equivalent to a
Turing machine
• Based on natural phenomena
– e.g. the generation of patterns on seashells
• Most famous example - "Game of Life"
– created by John Conway
Game of Life
• Infinite square grid; some cells are
"alive", others are "dead"
• Cells can die or
come to life
depending on
their neighbors
The rules of life
• If a live cell has fewer than 2 live
neighbors, it dies (loneliness)
• If a live cell has more than 3 live
neighbors, it dies (overcrowding)
• If a live cell has 2 or 3 live neighbors, it
goes on living
• If a dead cell has exactly 3 live neighbors,
it becomes alive (reproduction)
How the game runs
• The game proceeds in generations
• Initially, a finite number of cells is
live
• In each generation, some cells
become live and some die according
to the rules
Example:
Why this game is
addictive...
• Various interesting patterns emerge
– "gliders", "spaceships"
– demo (see website, Resources section,
for references)
Computing with the Game
of Life
• Prime numbers (demo)
• Can make a full Turing machine!
• Game of Life is just one example of
cellular automata
– many more exist; for example, 1-dimensional
CAs
– even 1-dimensional CAs can simulate a TM!
More on computation in
nature
• Another model - L-systems (similar
to CFGs/CSGs)
– related to fractals
– JFLAP can handle L-systems
– for references see course website
• Fun reading: "The Computational
Beauty of Nature", by Gary W. Flake
Fun topic #2 - Quines
• Brought to us through the power of
recursion theory.
– A very deep theorem called the
Recursion Theorem is behind quines
• A quine is a program that prints
itself out.
From our course website
- Java Quine
class Quine {
public static void main(String[] v) {
char c = 34;
System.out.print(s+c+s+c+';'+'}');
}
static String s =
"class Quine{public static void main(String[]v){char
c=34;System.out.print(s+c+s+c+';'+'}');}static String s=";
}
How does it work? (is it
magic?)
• A quine in English:
Print two copies of the following, the second one in
quotes:
"Print two copies of the following, the second one in
quotes:"
• A quine has 2 parts:
– "code" - instructions for printing
– "data" - includes a listing of the code
Java Quine, revisited
class Quine {
public static void main(String[] v) {
char c = 34;
System.out.print(s+c+s+c+';'+'}');
Data
}
static String s =
"class Quine{public static void main(String[]v){char
c=34;System.out.print(s+c+s+c+';'+'}');}static String s=";
}
Java Quine, revisited
class Quine {
public static void main(String[] v) {
char c = 34;
System.out.print(s+c+s+c+';'+'}');
Code (compare
with data!)
Data
}
static String s =
"class Quine{public static void main(String[]v){char
c=34;System.out.print(s+c+s+c+';'+'}');}static String s=";
}
Java Quine, revisited
class Quine {
public static void main(String[] v) {
char c = 34;
System.out.print(s+c+s+c+';'+'}');
Print 2 copies of
data, second one in
quotes, followed by ;
and }
Data
}
static String s =
"class Quine{public static void main(String[]v){char
c=34;System.out.print(s+c+s+c+';'+'}');}static String s=";
}
Output of Java Quine?
(with spaces added)
class Quine {
public static void main(String[] v) {
char c = 34;
System.out.print(s+c+s+c+';'+'}');
First copy of
data
}
static String s =
"class Quine{public static void main(String[]v){char
c=34;System.out.print(s+c+s+c+';'+'}');}static String s=";
}
Closing ; and }
Second
copy of
data
Quotes
More quines
• Can make quines in any Turing-complete language - see
website refs.
• Can even make a TM that prints out its own description on
the tape!
• The closest thing to the above is a quine in BrainF***:
->++>+++>+>+>+++>>>>>>>>>>>>>>>>>>>>>>+>+>++>+++>++>>
+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>>+++>>>>+++>>>
+++>+>>>>>>>++>+++>+++>+>+++>+>>+++>>>+++>+>++>+++>>
>+>+>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+
>>+++>+++>+>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>+
++>+>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>+[
[>>+[>]+>+[<]<-]>>[>]<+<+++[<]<<+]>+[>>]+++>+[+[<++++++
++++++++++>-]<++++++++++.<]
Confused enough?
• If a TM can print out its own
description on the tape (through a
quine), it can then use that
description to simulate itself on
something!
– Huh?
– The recursion theorem talks about that
(kind of)
Fun topic # 3 - P vs NP
• Restrict TMs so that they have to
halt in polynomially many time steps
(in the length of the input)
• What class of problems can be solved
in polynomial time?
– Depends if the machine is deterministic
or not (maybe!!)
P vs NP
• P = class of problems that can be
solved in PTIME on a deterministic
TM
• NP = class of problems that can be
solved in PTIME on a
nondeterministic TM
An example of a problem
in NP
• Hamiltonian Cycle
– Given an undirected graph, find a cycle that
visits each vertex exactly once.
• Can do it in NP - guess the cycle and verify
that it's correct
– verification step itself takes polynomial time
• But can we find it fast, without guessing?
Lots of problems known
to be in NP
• You'll see some of them in 482
• Factoring - important for crypto
• We even have reductions between them; if
we could solve HAMCYCLE in polynomial
time, would immediately have solutions for
multiple other problems
• But a general proof that P = NP or not still
eludes us
Next week
• Review session Tuesday July 5th
– send me your questions, or come armed
with them
• Final exam July 6th, 3-5:30 pm
– watch CMS for sample questions on TMs
– cumulative, but somewhat more
emphasis on TMs
381