1. Lecture 9 Recursive and r.e. language classes
representing solvable and unsolvable problems
Proofs of closure properties
for the set of recursive (solvable) languages
for the set of r.e. (half-solvable) languages
Generic element/template proof technique
Relationship between RE and REC
pseudoclosure property

2. RE and REC language classes
A solvable language is commonly referred to as a recursive language for historical reasons
REC is defined to be the set of solvable or recursive languages RE
A half-solvable language is commonly referred to as a recursively enumerable or r.e. language
RE is defined to be the set of r.e. or half-solvable languages

3. Why study closure properties of RE and REC?
It tests how well we really understand the concepts we encounter
language classes, REC, solvability, half-solvability
It highlights the concept of subroutines and how we can build on previous algorithms to construct new algorithms
we don’t have to build our algorithms from scratch every time

4. Example Application Setting Question
I have two programs which can solve the language recognition problems for L1 and L2
I want a program which solves the language recognition problem for L1 intersect L2
Question
Do I need to develop a new program from scratch or can I use the existing programs to help?
Does this depend on which languages L1 and L2 I am working with?

5. Closure Properties of REC
We now prove REC is closed under two set operations
Set Complement
Set Intersection
In these proofs, we try to highlight intuition and common sense

6. Quick Questions What does the following statement mean?
REC is closed under the set complement operation
How do you prove a language L is in REC?

7. Set Complement Example
Even: the set of even length strings over {0,1}
Complement of Even?
Odd: the set of odd length strings over {0,1}
Is Odd recursive (solvable)?
How is the program P’ which solves Odd related to the program P which solves Even?

8. Set Complement Lemma
If L is a solvable language, then L complement is a solvable language
Rewrite this in first-order logic
Proof
Let L be an arbitrary solvable language
First line comes from For all L in REC
Let P be the C++ program which solves L
P exists by definition of REC

9. proof continued Modify P to form P’ as follows
Identical except at very end
Complement answer
Yes -> No
No -> Yes
Program P’ solves L complement
Halts on all inputs
Answers correctly
Thus L complement is solvable
Definition of solvable

10. P’ Illustration P’
YES No P
YES
Input x No

11. Code for P’ bool main(string y) {
if (P (y)) return no; else return yes; }
bool P (string y) /* details unknown */

12. Set Intersection Example
Even: the set of even length strings over {0,1}
Mod-5: the set of strings of length a multiple of 5 over {0,1}
What is Even intersection Mod-5?
Mod-10: the set of strings of length a multiple of 10 over {0,1}
How is the program P3 (Mod-10) related to programs P1 (Even) and P2 (Mod-5)

13. Set Intersection Lemma
If L1 and L2 are solvable languages, then L1 intersection L2 is a solvable language
Rewrite this in first-order logic
Note we have two languages because intersection is a binary operation
Proof
Let L1 and L2 be arbitrary solvable languages
Let P1 and P2 be programs which solve L1 and L2, respectively

14. proof continued Construct program P3 from P1 and P2 as follows
P3 runs both P1 and P2 on the input string
If both say yes, P3 says yes
Otherwise, P3 says no
P3 solves L1 intersection L2
Halts on all inputs
Answers correctly
L1 intersection L2 is a solvable language

15. P3 Illustration
AND
Yes/No P3 P1
Yes/No
Yes/No P2

16. Code for P3 bool main(string y) { if (P1(y) && P2(y)) return yes;
else return no; }
bool P1(string y) /* details unknown */
bool P2(string y) /* details unknown */

17. Other Closure Properties
Unary Operations
Language Reversal
Kleene Star
Binary Operations
Set Union
Set Difference
Symmetric Difference
Concatenation

18. Closure Properties of RE
We now try to prove RE is closed under the same two set operations
Set Intersection
Set Complement
In these proofs
We define a more formal proof methodology
We gain more intuition about the differences between solvable and half-solvable problems

19. Quick Questions What does the following statement mean?
RE is closed under the set intersection operation
How do you prove a language L is in RE?

20. 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

21. 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

22. 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 half-solve 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

23. Set Intersection Example
Let L1 and L2 be arbitrary r.e. languages
There exist P1 and P2 s.t. Y(P1)=L1 and Y(P2)=L2
By definition of half-solvable languages
Construct program P3 from P1 and P2
Note, we can assume very little about P1 and P2
Prove Program P3 half-solves L1 intersection L2
There exists a program P which half-solves L1 intersection L2
L1 intersection L2 is an r.e. language

24. 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

25. 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

26. P3 Illustration
AND
Yes/No/- P3
Input P1
Yes/No/-
Yes/No/- P2

27. Code for P3 bool main(string y) {
parallel-execute(P1(y), P2(y)) until both return;
if ((P1(y) && P2(y)) return yes;
else return no; }
bool P1(string y) /* details unknown */
bool P2(string y) /* details unknown */

28. Proving P3 Is Correct
2 steps to showing P3 half-solves 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

29. 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

30. 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 is 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 is not in L2
Essentially identical analysis

31. RE closed under set complement?
First-order logic formulation?
For all L in RE, L complement in RE
For all L (L in RE) --> ((L complement) in RE)
What this really means
Let Li denote the ith r.e. language
L1 complement is in RE
L2 complement is in RE
...

32. Set complement proof overview
Let L be an arbitrary r.e. language
There exists P s.t. Y(P)=L
By definition of r.e. languages
Construct program P’ from P
Note, we can assume very little about P
Prove Program P’ half-solves L complement
There exists a program P’ which half-solves L complement
L complement is an r.e. language

33. 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

34. 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

35. Other closure properties
Unary Operations
Language reversal
Kleene Closure
Binary operations
union
concatenation
Not closed
Set difference

36. 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

37. 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

38. Example Looping Problem Looping Problem is unsolvable Input
Program P
Input x for program P
Yes/No Question
Does P loop on x?
Looping Problem is unsolvable
Looping Problem complement = H

39. Closure Property Applications
Proving a new closure property
Theorem: Unsolvable languages are closed under set complement
Let L be an arbitrary unsolvable language
If Lc is solvable, then L is solvable
(Lc)c = L
Solvable languages closed under complement
However, we are assuming that L is unsolvable
Therefore, we can conclude that Lc is unsolvable
Thus, unsolvable languages are closed under complement

40. Pseudo Closure Property
Lemma: If L and Lc are half-solvable, then L is solvable.
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 solvable because REC closed under set complement

41. High Level Proof
Let L be an arbitrary language where L and Lc are both half-solvable
Let P1 and P2 be the programs which half-solve L and Lc, respectively
Construct program P3 from P1 and P2
Argue P3 solves L
L is solvable

42. Constructing P3 Problem Key Observation
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

43. Illustration S* L
P1 halts Lc
P2 halts

44. Construction and Proof
P3’s Operation
Run P1 and P2 in parallel on the input string x until one accepts x
Guaranteed to occur given previous argument
Also, only one program will accept any string x
IF P1 is the accepting machine THEN yes ELSE no

45. P3 Illustration P3
Input
Yes No P1
Yes
Yes P2

46. Code for P3 bool main(string y) {
parallel-execute(P1(y), P2(y)) until one returns yes;
if (P1(y)) return yes;
if (P2(Y)) return no; }
bool P1(string y) /* details unknown */
bool P2(string y) /* details unknown */

47. 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.

48. RE and REC
All Languages RE
REC L Lc

49. RE and REC All Languages RE Lc Lc L REC Lc
Are there any languages L in RE - REC?