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

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

Illustration L(P) Accepts Rejects Crashes S* Loops

REC and RE Language Classes 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

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

Illustration of Mapping All Programs RE Halting Programs REC 2 key points: Mapping is a relation, not a function Some nonhalting programs map to recursive languages

Languages RE REC REC is a proper subset of RE Halting Language REC is a proper subset of RE RE is a proper subset of the set of all languages.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Illustration S* L P1 halts Lc P2 halts

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

P3 Illustration P3 Input Yes No P1 Yes Yes P2

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.

RE and REC S* RE REC L Lc

RE and REC S* RE Lc Lc L REC Lc Are there any languages L in RE - REC?

Summary Programs and Input Strings RE and REC Closure Properties Why we care about RE Details on their relationship Closure Properties Generic Element or Template Proofs Some operations NOT closed for RE Applications