Lecture 9 Recursive and r.e. language classes

Slides:



Advertisements
Similar presentations
Chapter Three: Closure Properties for Regular Languages
Advertisements

CS 461 – Nov. 9 Chomsky hierarchy of language classes –Review –Let’s find a language outside the TM world! –Hints: languages and TM are countable, but.
1 Lecture 32 Closure Properties for CFL’s –Kleene Closure construction examples proof of correctness –Others covered less thoroughly in lecture union,
1 COMP 382: Reasoning about algorithms Unit 9: Undecidability [Slides adapted from Amos Israeli’s]
1 Introduction to Computability Theory Lecture15: Reductions Prof. Amos Israeli.
1 Introduction to Computability Theory Lecture12: Reductions Prof. Amos Israeli.
Finite Automata Great Theoretical Ideas In Computer Science Anupam Gupta Danny Sleator CS Fall 2010 Lecture 20Oct 28, 2010Carnegie Mellon University.
1 Introduction to Computability Theory Lecture13: Mapping Reductions Prof. Amos Israeli.
Prof. Busch - LSU1 Decidable Languages. Prof. Busch - LSU2 Recall that: A language is Turing-Acceptable if there is a Turing machine that accepts Also.
1 Lecture 4: Formal Definition of Solvability Analysis of decision problems –Two types of inputs:yes inputs and no inputs –Language recognition problem.
1 Module 15 FSA’s –Defining FSA’s –Computing with FSA’s Defining L(M) –Defining language class LFSA –Comparing LFSA to set of solvable languages (REC)
1 Lecture 14 Language class LFSA –Study limits of what can be done with FSA’s –Closure Properties –Comparing to other language classes.
Fall 2004COMP 3351 Recursively Enumerable and Recursive Languages.
1 Module 9 Recursive and r.e. language classes –representing solvable and half-solvable problems Proofs of closure properties –for the set of recursive.
Lecture 8 Recursively enumerable (r.e.) languages
Fall 2003Costas Busch - RPI1 Decidability. Fall 2003Costas Busch - RPI2 Recall: A language is decidable (recursive), if there is a Turing machine (decider)
1 Undecidability Andreas Klappenecker [based on slides by Prof. Welch]
Recursively Enumerable and Recursive Languages
1 Module 7 Halting Problem –Fundamental program behavior problem –A specific unsolvable problem –Diagonalization technique revisited Proof more complex.
1 Lecture 26 Decision problems about regular languages –Basic problems are solvable halting, accepting, and emptiness problems –Solvability of other problems.
1 Module 11 Proving more specific problems are not solvable Input transformation technique –Use subroutine theme to show that if one problem is unsolvable,
1 Uncountable Sets continued Theorem: Let be an infinite countable set. The powerset of is uncountable.
Fall 2004COMP 3351 The Chomsky Hierarchy. Fall 2004COMP 3352 Non-recursively enumerable Recursively-enumerable Recursive Context-sensitive Context-free.
1 Lecture 10 Proving more specific problems are not recursive Reduction technique –Use subroutine theme to show that if one problem is unsolvable, so is.
1 Lecture 7 Halting Problem –Fundamental program behavior problem –A specific unsolvable problem –Diagonalization technique revisited Proof more complex.
1 Lecture 16 FSA’s –Defining FSA’s –Computing with FSA’s Defining L(M) –Defining language class LFSA –Comparing LFSA to set of solvable languages (REC)
CHAPTER 4 Decidability Contents Decidable Languages
1 Lecture 7 Halting Problem –Fundamental program behavior problem –A specific unsolvable problem –Diagonalization technique revisited Proof more complex.
1 Lecture 16 FSA’s –Defining FSA’s –Computing with FSA’s Defining L(M) –Defining language class LFSA –Comparing LFSA to set of solvable languages (REC)
1 Lecture 5 Topics –Closure Properties for REC Proofs –2 examples Applications.
1 Lecture 18 Closure Properties of Language class LFSA –Remember ideas used in solvable languages unit –Set complement –Set intersection, union, difference,
1 Strings and Languages Operations Concatenation Exponentiation Kleene Star Regular Expressions.
1 Lecture 11 Proving more specific problems are not solvable Input transformation technique –Use subroutine theme to show that if one problem is unsolvable,
1 Module 11 Proving more specific problems are not solvable Input transformation technique –Use subroutine theme to show that if one problem is unsolvable,
1 Lecture 7 Topics –Problems about program behavior At least problem input is a program/algorithm –Halting Problem Fundamental problem about program behavior.
1 Module 31 Closure Properties for CFL’s –Kleene Closure construction examples proof of correctness –Others covered less thoroughly in lecture union, concatenation.
1 Lecture 23 Decision problems about regular languages –Programs can be inputs to other programs FSA’s, NFA’s, regular expressions –Basic problems are.
Fall 2005Costas Busch - RPI1 Recursively Enumerable and Recursive Languages.
1 Module 4: Formal Definition of Solvability Analysis of decision problems –Two types of inputs:yes inputs and no inputs –Language recognition problem.
CS21 Decidability and Tractability
1 Lecture 11 Proving more specific problems are not solvable Input transformation technique –Use subroutine theme to show that if one problem is unsolvable,
1 Strings and Languages Operations Concatenation Exponentiation Kleene Star Regular Expressions.
1 Module 10 Recursive and r.e. language classes –representing solvable and half-solvable problems Proofs of closure properties –for the set of recursive.
1 Reducibility. 2 Problem is reduced to problem If we can solve problem then we can solve problem.
1 Module 9 Closure Properties –Definition –Language class definition set of languages –Closure properties and first-order logic statements For all, there.
1 Undecidability Reading: Chapter 8 & 9. 2 Decidability vs. Undecidability There are two types of TMs (based on halting): (Recursive) TMs that always.
1 1 CDT314 FABER Formal Languages, Automata and Models of Computation Lecture 15-1 Mälardalen University 2012.
A Universal Turing Machine
1 Turing’s Thesis. 2 Turing’s thesis: Any computation carried out by mechanical means can be performed by a Turing Machine (1930)
 2005 SDU Lecture13 Reducibility — A methodology for proving un- decidability.
Chapter 8 Properties of Context-free Languages These class notes are based on material from our textbook, An Introduction to Formal Languages and Automata,
Lecture 21 Reducibility. Many-one reducibility For two sets A c Σ* and B c Γ*, A ≤ m B if there exists a Turing-computable function f: Σ* → Γ* such that.
Recursively Enumerable and Recursive Languages
1 Module 17 Closure Properties of Language class LFSA –Remember ideas used in solvable languages unit –Set complement –Set intersection, union, difference,
Finite Automata Great Theoretical Ideas In Computer Science Victor Adamchik Danny Sleator CS Spring 2010 Lecture 20Mar 30, 2010Carnegie Mellon.
Decidability Decidable/Undecidable problems. Jaruloj Chongstitvatana Decidability2 Accepting: Definition Let T = (Q, , , , s) be a TM. T accepts.
1 Strings and Languages Operations Concatenation Exponentiation Kleene Star Regular Expressions.
Decidability.
Module 7 Halting Problem –Fundamental program behavior problem –A specific unsolvable problem –Diagonalization technique revisited Proof more complex 1.
Chapters 11 and 12 Decision Problems and Undecidability.
CSE 105 theory of computation
MCC 2093 Advanced Theoretical Computer Science
Busch Complexity Lectures: Undecidable Problems (unsolvable problems)
Decidable Languages Costas Busch - LSU.
Formal Languages, Automata and Models of Computation
Instructor: Aaron Roth
CS21 Decidability and Tractability
Cpt S 317: Spring 2009 Reading: Chapter 8 & 9
More Undecidable Problems
Presentation transcript:

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

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

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

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?

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

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?

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?

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

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

P’ Illustration P’ YES No P YES Input x No

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

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)

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

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

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

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 */

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

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

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?

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

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

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

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 */

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

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

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

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

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

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

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

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

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

P3 Illustration P3 Input Yes No P1 Yes Yes P2

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 */

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 All Languages RE REC L Lc

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