Transcript Lecture 8

Lecture 8
• Recursively enumerable (r.e.) languages
– accommodates non-halting programs
• Closure properties of r.e. languages
– different than for recursive languages
– generic element/template proof technique
• Relationship between RE and REC
– pseudoclosure property
1
Programs and Input Strings
• Notation
– P denotes a program
– x denotes an input string for program P
• 4 possible outcomes of running P on x
– P halts and says yes: P accepts string x
– P halts and says no: P rejects string x
– P halts without saying yes or no: P crashes on input x
• We typically ignore this case as it can be combined with rejects
– P never halts: P loops on input x
• L(P): the set of strings accepted by P
2
Illustration
S*
Accepts
L(P)
Rejects
Crashes
Loops
3
REC and RE Language Classes
• RE
– A language L is recursively enumerable (r.e.) iff there
exists some program P s.t. L = L(P)
• REC languages
– A language L is recursive iff there exists some program
P s.t L = L(P) and P always halts
• REC proper subset RE
– Halting problem is r.e. but not recursive
• Notation
– RE, r.e. language, REC, recursive language
4
Why study RE?
• A correct algorithm must halt on all inputs
– We only consider recursive languages to be solved languages
• Why then do we define and study RE?
– One Answer: RE is the natural class of problems/languages
associated with any general computational model like C++
– That is, there is a 2-way mapping between programs and r.e.
languages
• Every program P accepts an r.e. language L and every r.e. language is
accepted by some program P
– There is no such 2-way mapping between recursive languages and
programs
• Some programs which do not halt do not map to any recursive
language
5
Illustration of Mapping
All Programs
Halting Programs
2 key points:
Mapping is a relation, not a function
Some nonhalting programs
map to recursive languages
REC
RE
6
Languages
RE
REC
Halting Language
REC is a proper subset of RE
RE is a proper subset of the set of all languages.
7
RE Closed Under Set Intersection
• First-order logic formulation?
– For all L1, L2 in RE, L1 intersect L2 in RE
– For all L1, L2 ((L1 in RE) and (L2 in RE) --> ((L1 intersect L2) in RE)
• What this really means
– Let Li denote the ith r.e. language
•
•
•
•
•
L1 intersect L1 is in RE
L1 intersect L2 is in RE
...
L2 intersect L1 is in RE
...
8
Generic Element or Template
Proofs
• Since there are an infinite number of facts
to prove, we cannot prove them all
individually
• Instead, we create a single proof that proves
each fact simultaneously
• I like to call these proofs generic element or
template proofs
9
Basic Proof Ideas
• Name your generic objects
– In this case, we use L1 and L2
• Only use facts which apply to any relevant
objects
– We will only use the fact that there must exist
P1 and P2 which accept L1 and L2
• Work from both ends of the proof
– The first and last lines are usually obvious, and
we can often work our way in
10
Set Intersection Example
• Let L1 and L2 be arbitrary r.e. languages
• There exist P1 and P2 s.t. L(P1)=L1 and L(P2)=L2
– By definition of r.e. languages
• Construct program P3 from P1 and P2 [Subroutine]
– Note, we can assume very little about P1 and P2
• Prove Program P3 accepts L1 intersection L2
• There exists a program P which accepts L1
intersection L2
• L1 intersection L2 is an r.e. language
11
Constructing P3
• What did we do in the REC setting?
• Build P3 using P1 and P2 as subroutines
• We just have to be careful now in how we
use P1 and P2
12
Constructing P3
• Run P1 and P2 in parallel
– One instruction of P1, then one instruction of
P2, and so on
• If both halt and say yes, halt and say yes
• If both halt but both do not say yes, halt and
say no
– Note, if either never halts, P3 never halts
13
P3 Illustration
P1
Input
Yes/No/P3
P2
AND
Yes/No/-
Yes/No/-
14
Proving P3 Is Correct
• 2 steps to showing P3 accepts L1
intersection L2
– For all x in L1 intersection L2, must show P3
• accepts x
– halts and says yes
– For all x not in L1 intersection L2, must show P3
• rejects x or
• loops on x or
• crashes on x
15
Part 1 of Correctness Proof
• P3 accepts x in L1 intersection L2
– Let x be an arbitrary string in L1 intersection L2
• Note, this subproof is a generic element proof
– P1 accepts x
• L1 intersection L2 is a subset of L1
• P1 accepts all strings in L1
– P2 accepts x
– P3 accepts x
• We reach the AND gate because of the 2 previous facts
• Since both P1 and P2 accept, AND evaluates to YES
16
Part 2 of Correctness Proof
• P3 does not accept x not in L1 intersection L2
– Let x be an arbitrary string not in L1 intersection L2
– By definition of intersection, this means x is not in L1 or L2
– Case 1: x not in L1
• 2 possibilities
• P1 rejects (or crashes on) x
– One input to AND gate is No
– Output cannot be yes
– P3 does not accept x
• P1 loops on x
– One input never reaches AND gate
– No output
– P3 loops on x
• P3 does not accept x when x is not in L1
– Case 2: x not in L2
• Essentially identical analysis
– P3 does not accept x not in L1 intersection L2
17
Set complement Example
• Let L be an arbitrary r.e. language
• There exists P s.t. L(P)=L
– By definition of r.e. languages
• Construct program P’ from P [Subroutine Theme]
– Note, we can assume very little about P
• Prove Program P’ accepts L complement
• There exists a program P’ which accepts L
complement
• L complement is an r.e. language
18
Constructing P’
• What did we do in recursive case?
– Run P and then just complement answer at end
• Accept -> Reject
• Reject -> Accept
• Does this work in this case?
– No. Why not?
• Accept->Reject and Reject ->Accept ok
• Problem is we need to turn Loop->Accept
– this requires solving the halting problem
19
What can we conclude?
• Previous argument only shows that the
approach used for REC does not work for
RE
• This does not prove that RE is not closed
under set complement
• Later, we will prove that RE is not closed
under set complement
20
Other closure properties
• Unary Operations
– Language reversal
– Kleene Closure
• Binary operations
– union
– concatenation
• Not closed
– Set difference
21
Closure Property Applications
• How can we use closure properties to prove
a language LT is r.e. or recursive?
• Unary operator op (e.g. complement)
– 1) Find a known r.e. or recursive language L
– 2) Show LT = L op
• Binary operator op (e.g. intersection)
– 1) Find 2 known r.e or recursive languages L1 and L2
– 2) Show LT = L1 op L2
22
Closure Property Applications
• How can we use closure properties to prove
a language LT is not r.e. or recursive?
• Unary operator op (e.g. complement)
– 1) Find a known not r.e. or non-recursive language L
– 2) Show LT op = L
• Binary operator op (e.g. intersection)
– 1) Find a known r.e. or recursive language L1
– 2) Find a known not r.e. or non-recursive language L2
– 2) Show L2 = L1 op LT
23
Example
• Looping Problem
– Input
• Program P
• Input x for program P
– Yes/No Question
• Does P loop on x?
• Looping Problem is undecidable
– Looping Problem complement = H
24
Closure Property Applications
• Proving a new closure property
• Theorem: Nonrecursive languages are closed under set
complement
– Let L be an arbitrary nonrecursive language
– If Lc is recursive, then L is recursive
• (Lc)c = L
• Recursive languages closed under complement
– However, we are assuming that L is not recursive
– Therefore, we can conclude that Lc is not recursive
– Thus, nonrecursive languages are closed under complement
25
Pseudo Closure Property
• Lemma: If L and Lc are r.e., then L is recursive.
• First-order logic?
– For all L in RE, (Lc in RE) --> (L in REC)
– For all L, ((L in RE) and (Lc in RE)) --> (L in REC)
• Question: What about Lc?
– Also recursive because REC closed under set
complement
26
High Level Proof
– Let L be an arbitrary language where L and Lc
are both r.e.
– Let P1 and P2 be the programs which accept L
and Lc, respectively
– Construct program P3 from P1 and P2
[Subroutine theme]
– Argue P3 decides L
– L is recursive
27
Constructing P3
• Problem
– Both P1 and P2 may loop on some input strings,
and we need P3 to halt on all input strings
• Key Observation
– On all input strings, one of P1 and P2 is
guaranteed to halt. Why?
• Nature of complement operation
28
Illustration
S*
L
Lc
P1 halts
P2 halts
29
Construction and Proof
• P3’s Operation
– Run P1 and P2 in parallel on the input string x
until one accepts x
• Guranteed to occur given previous argument
• Also, only one program will accept any string x
– IF P1 is the accepting machine THEN yes ELSE
no
30
P3 Illustration
P1
Input
Yes
Yes
P3
P2
Yes
No
31
Question
• What if P2 rejects the input?
• Our description of P3 doesn’t describe what
we should do in this case.
– If P2 rejects the input, then the input must be in
L
– This means P1 will eventually accept the input.
– This means P3 will eventually accept the input.
32
RE and REC
S*
RE
L
REC
Lc
33
RE and REC
S*
Lc
L
Lc
RE
Lc REC
Are there any languages L in RE - REC?
34
Summary
• Programs and Input Strings
• RE and REC
– Why we care about RE
– Details on their relationship
• Closure Properties
– Generic Element or Template Proofs
– Some operations NOT closed for RE
– Applications
35