Download Presentation

Loading in 3 Seconds

This presentation is the property of its rightful owner.

X

Sponsored Links

- 53 Views
- Uploaded on
- Presentation posted in: General

CSC3130 Formal Languages and Automata Theory Tutorial 9 Undecidable Problem

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

CSC3130Formal Languages andAutomata TheoryTutorial 9Undecidable Problem

KN Hung

SHB 1026

- Recap
- Decidibility, Undecidibility, Turing-Recognizable …

- Reduction
- Undecidable Problem

Recap

- Given a language L and a machine M
“MrecognizesL” iff

“For any w ∈ L, M halts and goes to an accepting state”

- “M is a recognizer for L”
- However, for w ∉ L, M may
- Reject
- Loop forever

- Given a language L and a machine M
“MdecidesL” iff

“For any w ∈ L, M halts and accepts AND

Otherwise, M rejects”

- “M is a decider for L”
- Meaning: M can determine whether a given string is in L or not

- Recognize = Halts for accepting input
- Decide = Halts for all inputs
- Decide => Recognize
- Make sure that you can distinguish these two concepts!

- L is Turing-recognizable iffthere is a TM that recognizes L
- L is decidable iffthere is a TM that decides L
- L is undecidable iffthere is no TM that decides L

Turing-Recognizable

Decidable

For a language, L, located here,there is no machine that halts for all input string

- The following problems are decidable
- ADFA = {<A, w> | A is a DFA that accepts w}
- ANFA = {<A, w> | A is a NFA that accepts w}
- EDFA= {<A, w> | A is a DFA and L(A) = Ø}
- EQDFA = {<A, B> | A, B are DFAs, L(A) = L(B)}
- ACFG = {<G, w> | G is a CFG that generates w}

- The following problems are undecidable
- ATM = {<M, w> | M is a TM that accepts w}
- To prove undecidability of a problem using reduction, ATM is used very frequently (nearly in all situations)
- Used in Example 1 and 2 (Later slides)

- ATM = {<M, w> | M is a TM that accepts w}

Reduction

- Occurs in daily life…
- Problem A: Travel to Japan
- Problem B: Buying a air ticket to Japan
- Problem Areduces toProblem B
- Meaning: Settling B automatically solves A
- Put in logical statement:
B is solvable A is solvable

Buy an air ticket

Reduce to

Travel to Japan

The problem “To buy an air ticket”enclosesThe problem “To travel to Japan”

B

Reduce to

A

Problem B“encloses”ASo, B is solved => A is solvedThus, B is no harder than A!

B

- A reduces to B
- A is reducible to B
- If B is solved, then A is solved
- i.e., Whenever there is a solution to B,then there is a solution to A

- If A cannot be solved, then B cannot be solved (Contrapositive)
- Thus, B is no harder than A

Reduced to

A

Undecidable Problems

- Show that REGULARTM is undecidable
- REGULARTM = {<M> | M is a TM and L(M) is a regular language}

- Idea (By Contradiction):
- Assume there is a TM R that decides REGULARTM
- Construct a TM S that decides ATM
- Contradiction!

- On input <M, w>
- where M is a TM and w is a string:

- Construct M’ by M and w
- Run R on <M’>
- Output the answer

- Strategy: Convert M into another TM M’: M’ recognizes a regular languageiffM accepts w
- If M accepts w, let M’ recognizes {0, 1}*
- Otherwise, let M’ recognizes {0n1n}
- With the above properties
- When we run R on <M’>,
the output is “accept” iffM accepts w

- Why…? [See next few slides…]

- When we run R on <M’>,

- M’ = “On input x:
- If x has the form 0n1n, accept
- If x does not have this form, run M on input wand output answer”

- {0n1n} is recognized by M’ anyway
- How about the other strings?

- For strings of form 0n1n, M’ accepts
- For all the other strings, listing all cases…
- If M accepts w
- they are all accepted by M’

- If M rejects w
- they are all rejected by M’

- If M loops on w
- they all loop on M’

- If M accepts w

- M’ = “On input x:
- If x has the form 0n1n, accept
- If x does not have this form, run M on input wand output answer”

- If M accepts w
- M’ recognizes {0n1n}∪{0,1}*
- {0,1}* is regular
- R will accept M’

- If M does not accept w
- M’ recognizes {0n1n}∪Ø
- {0n1n} is not regular
- R will reject M’

- Assume “R that decides REGULARTM” exists
- We construct S to decide ATM
“On input <M, w>, where M is a TM and w is a string:

- Construct the following TM M’
M’ = “On input x:

- If x has the form 0n1n, accept
- If x does not have this form, run M on input w and accept if M accepts w”
2. Run R on input <M’>

3. Output the output of R”

- Construct the following TM M’

- L = {<M, w> |M accepts all strings shorter than w}
- Show that L is undecidable

- L = {<M, w> |M accepts all strings shorter than w}
- Again, we try to use the undecidability of ATM to achieve a contradiction
- Idea (By Contradiction):
- Assume there is a TM R that decides L
- Construct a TM (by R), S that decides ATM
- Contradiction!

- On input <M, w>
- where M is a TM and w is a string:

- Construct M’ by M and w
- Run R on <M’, ?>
- This time, we have a TM that takes 2 arguments – a TM, and a string – as inputs
- Think what string to put as the 2nd input

- Output the answer

- Strategy: Convert M into another TM M’: M’ accepts all strings shorter than ziffM accepts w
- We want to achieve the following:
- When we run R on <M’, z>,
the output is “accept” iffM accepts w

- When we run R on <M’, z>,

- Strategy: Convert M into another TM M’: M’ accepts all strings shorter than “1”iffM accepts w
- We want to achieve the following:
- When we run R on <M’, “1”>,
the output is “accept” iffM accepts w

- When we run R on <M’, “1”>,

- M’ = “On input x:
- If x =ε
Run M on w

Output the answer

- If x ≠ε
Reject

- If x =ε

- For M’
- If M accepts w
- the only possibility is input isε ANDM’ accepts ε

- If M rejects w,
- Case 1: x=ε
- M’ rejects

- Case 2: x ≠ε
- M’ rejects

- Case 1: x=ε
- If M loops on w
- Case 1: x=ε
- M’ loops

- Case 2: x ≠ε
- M’ rejects

- Case 1: x=ε

- If M accepts w

- M’ = “On input x:
- If x =ε run M on w and output answer
- If x ≠ε reject”

- For M’
- If M accepts w
- M’ accepts only ε

- Otherwise
- M’ does not accepts any string
- including ε

- M’ does not accepts any string

- If M accepts w

- M’ = “On input x:
- If x =ε run M on w and output answer
- If x ≠ε reject”

- If M accepts w
- L(M’) = {ε}
- {ε} is exactly the language that contains all string shorter than “1”
- S accepts <M’, “1”>

- Otherwise (i.e., M loops on or rejects w)
- L(M’) = Ø
- S rejects <M’, “1”>

- Assume “R that decides REGULARTM” exists
- We construct S to decide ATM
“On input <M, w>, where M is a TM and w is a string:

- Construct the following TM M’M’ = “On input x:
- If x =ε
Run M on x

Output the answer

- If x ≠ε
Reject

2. Run R on input <M’, “1”>

3. Output the output of R”

- If x =ε

- Construct the following TM M’M’ = “On input x:

Conclusion

- Given an undecidable language, L
- Assume such a decider TM R, exists

R

Given an undecidable language, L

Assume such a decider TM R, exists

Construct a TM, M’, by M and w

M is from input

R

Input

Modify

M

M’

w

37

Given an undecidable language, L

Assume such a decider TM R, exists

Construct a TM, M’, by M and w

M is from input

Feed M’ to R

R

Input

Modify

M

M’

w

38

“M acc w” then ACC

Otherwise,REJ

- Given an undecidable language, L
- Assume such a decider TM R, exists
- Construct a TM, M’, by M and w
- M is from input

- Feed M’ to R
- If you are right
- R will accept M’iff M accepts w
- R will reject M’iff M does not accept w

- Thus, you obtain a decider for ATM
- Contradiction!!

R

Input

Modify

M

M’

w

- Thanks for coming!
- I understand that this topic is confusing…
- Should have some questions?