This preview shows page 1. Sign up to view the full content.
Unformatted text preview: Reductions to the Halting Problem
Different Models Reductions Simple Reductions Rice's Theorem Reverse Reduction Acceptable The Post Correspondence Prob Tiling CFG G Generates I CFG G Generates Every String CFG G Generates Some String CFG L(G)=L(G') Game of Life Hilbert's 10th Problem Lecture 4 Jeff Edmonds York University COSC 4111 Reductions for Undecidability
Undecidable problems: Halting Problem ? = {<M,I>  TM M halts on input I} = {<J,I>  Java program J halts on input I} = {<P,I>  Primitive Recursive Program P halts on input I} = {<P,I>  Recursive Program P halts on input I} = {<P,I>  Register Machine halts on input I} = {<C,I>  Uniform circuit C halts on input I} = {<M,I>  Quantum Machine M Java halts on input I} = {<G,I>  Context Sensitive Grammar G generates string input I} = {<H,I>  Human H halts on input I} Every primitive recursive program halts. n, circuit computed in time size(n) Every human dies. Reductions for Undecidability Now that we have established that the Halting Problem is undecidable, we can use it for a jumping off point for more "natural" undecidability results. Palg poly Poracle Reductions Reduction: Design an algorithm for one computational problem, using a supposed algorithm for another problem as a subroutine. Palg poly Poracle Reductions Reduction: Design an algorithm for one computational problem, using a supposed algorithm for another problem as a subroutine. Used to create a new algorithm from a known algorithm. Learn that a new problem is likely hard, from knowing a known problem is likely hard. Learn that two problems have a similar "structure." Sam Bob John Fred Mary Beth Sue Ann Reductions
Matching poly Network Flows Who loves who Max matching s t A network BUILD:
Matching s t Max Flow GIVEN:
Network Flow Oracle Oracle Reductions
Computable Exp Halting Poly Learn that a new problem is likely hard, from knowing a known problem is likely hard. We give an algorithm for Palg using a supposed algorithm for Poracle as a subroutine. Reductions Is there an algorithm for Palg? Is there an algorithm for Poracle? ? We give an algorithm for Palg using a supposed algorithm for Poracle as a subroutine.
If there is an algorithm for Palg If there is not an algorithm for Palg then there is not fast ? algorithm for Poracle If there is not an algorithm for Poracle Reductions ???
If there is an algorithm for Poracle then there is an algorithm for Palg ? ??? We give an algorithm for Palg using a supposed algorithm for Poracle as a subroutine.
Conclusions: Reductions Palg is "at least as easy as" Poracle
(Modulo polynomial terms.) Poracle is "at least as hard as" Palg
(Modulo polynomial terms.) Notation: Palg poly Poracle Reductions for Undecidability
Halting Problem = {<M,I>  M halts on I} is undecidable Will prove: {<M,I>  M prints "Hi" at some point in computation on I} {<M>  M halts empty string} {<M>  M halts on every input} {<M>  M halts on some input} {<M>  L(M) is regular} {<M,M'>  I M(I) and M'(I)} There is a fixed TM M* {<I>  M* halts on I} {<M>  based on what M does, not on how it does it} poly {<M,I>  M halts on I} Hence, all are undecidable! Reductions for Undecidability
{<M,I>  M halts on I} {<M,I>  M prints "Hi" on I at some point in computation } <M',I> <M,I> M(I) halts M'(I) = { Run M(I), suppressing any output Print("Hi") }
BUILD: Oracle for {<M,I>  M halts on I} Yes, prints "Hi" GIVEN: Oracle for {<M,I>  M prints "Hi" on I} Reductions for Undecidability
{<M,I>  M halts on I} {<M,I>  M prints "Hi" on I at some point in computation } <M',I> <M,I> M(I) does not halt M'(I) = { Run M(I), suppressing any output Print("Hi") }
BUILD: Oracle for {<M,I>  M halts on I} No "Hi" GIVEN: Oracle for {<M,I>  M prints "Hi" on I} Reductions for Undecidability
{<M,I>  M halts on I} {<M>  M halts empty string} <M,I> M(I) halts or not <M'I> M'I(I') = { Ignore input I' I is a built in value Run M(I) } Yes or No
GIVEN: BUILD: Oracle for {<M,I>  M halts on I} Oracle for {<M>  M halts empty string} Reductions for Undecidability
{<M,I>  M halts on I} {<M>  M halts on every input} <M,I> M(I) halts or not MI(I') = { Ignore input I' I is a built in value Run M(I) }
BUILD: <MI> Oracle for {<M,I>  M halts on I} Yes or No GIVEN: Oracle for {<M>  M halts on every input} Reductions for Undecidability
{<M,I>  M halts on I} {<M>  M halts on some input} <M,I> M(I) halts or not MI(I') = { Ignore input I' I is a built in value Run M(I) }
BUILD: <MI> Oracle for {<M,I>  M halts on I} Yes or No GIVEN: Oracle for {<M>  M halts on some input} Reductions for Undecidability
{<M,I>  M halts on I} {<M>  L(M) is regular} <M,I> M(I) halts MI(I') = { Ignore input I' I is a built in value Run M(I) }
BUILD: <MI> Oracle for {<M,I>  M halts on I} L(MI) = {everything} Oracle for Yes , L(MI) is regular {<M>  L(M) is regular} GIVEN: Reductions for Undecidability
{<M,I>  M halts on I} {<M>  L(M) is regular} <M,I> M(I) does not halt MI(I') = { Ignore input I' I is a built in value Run M(I) }
BUILD: <MI> Oracle for {<M,I>  M halts on I} L(MI) = {nothing} Oracle for Yes, L(MI) is regular {<M>  L(M) is regular} GIVEN: Reductions for Undecidability
{<M,I>  M halts on I} {<M>  L(M) is regular} <M,I> <MI> MI(I') = M(I) does not halt { If I' has the form 0n1n halt and accept else run M(I) halt and accept }
BUILD: Oracle for {<M,I>  M halts on I} L(MI) = 0n1n Oracle for No, L(MI) is not regular {<M>  L(M) is regular} GIVEN: MI accepts 0n1n, but "computes" no language Reductions for Undecidability
{<M,I>  M halts on I} {<M>  L(M) is regular} <M,I> M(I) halts <MI> MI(I') = { If I' has the form 0n1n halt and accept else run M(I) halt and accept } L(MI) = {everything} Oracle for Yes, L(MI) is regular {<M>  L(M) is regular}
GIVEN: BUILD: Oracle for {<M,I>  M halts on I} Reductions for Undecidability
{<M,I>  M halts on I} {<M,M'>  I M(I)=M'(I)} <M,I> M(I) halts or not <MI,M'> MI(I') = M' = ? { Ignore input I' I is a built in value Run M(I) } Same or different
GIVEN: BUILD: Oracle for {<M,I>  M halts on I} Oracle for {<M,M'>  I M(I)=M'(I)} Reductions for Undecidability
{<M,I>  M halts on I} {<M,M'>  I M(I) and M'(I)} <MI,M'> MI(I') = M' = ? { Ignore input I' I is a built in value Run M(I) } If M halts on I MI halts on every input M' halts on every input MI and M' have the same results on every input Oracle says yes We say yes Reductions for Undecidability
{<M,I>  M halts on I} {<M,M'>  I M(I)=M'(I)} <MI,M'> MI(I') = M' = ? { Ignore input I' I is a built in value Run M(I) } If M does not halt on I MI does not halt on every input M' halts on every input MI and M' have different results on some input Oracle says no We say no Reductions for Undecidability
{<M,I>  M halts on I} {<M,M'>  I M(I)=M'(I)} <M,I> M(I) halts or not <MI,M'> MI(I') = { Ignore input I' I is a built in value Run M(I) } Yes or No ignores input and halts M' = ? BUILD: GIVEN: Oracle for {<M,I>  M halts on I} Oracle for {<M,M'>  I M(I) = M'(I)} Reductions for Undecidability
{<M,I>  M halts on I} {<I>  M* halts on I} where M* is a special TM <M,I> M(I) halts or not <I'> Need to tell oracle about M and I I' = <M,I> M* is the universal TM simulates M on I. Yes or No
GIVEN: BUILD: Oracle for {<M,I>  M halts on I} Oracle for {<I>  M* halts on I} Reductions for Undecidability
{<M,I>  M halts on I} Rice's Theorem L = {<M>  based on what M does, not on how it does it} If L(M) =L(M'), then ML iff ML' L {everything} L {nothing} Assume Mempty L, i.e. L(Mempty) = {nothing} (Else switch to L) Assume Myes L Reductions for Undecidability
{<M,I>  M halts on I} L = {<M>  based on what M does, not on how it does it} <M'> M'(I') = { Run M(I) Run Myes(I') respond as Myes(I') does }
BUILD: <M,I> M(I) halts Oracle for {<M,I>  M halts on I} L(M') = L(Myes) Myes L M' L
Yes GIVEN: Oracle for L Reductions for Undecidability
{<M,I>  M halts on I} L = {<M>  based on what M does, not on how it does it} <M'> M'(I') = { Run M(I) Run Myes(I') respond as Myes(I') does }
BUILD: <M,I> M(I) does not halt Oracle for {<M,I>  M halts on I} L(M') = {nothing} Oracle for = L(Mempty) Mempty L M' L L
No GIVEN: Reductions for Undecidability
Halting Problem = {<M,I>  M halts on I} is undecidable Will prove: {<M,I>  M prints "Hi" at some point in computation on I} {<M>  M halts empty string} {<M>  M halts on every input} {<M>  M halts on some input} {<M>  L(M) is regular} {<M,M'>  M=M' have the same results on every input} There is a fixed TM M* {<I>  M* halts on I} {<M>  based on what M does, not on how it does it} poly {<M,I>  M halts on I} Hence, all are undecidable! Reductions for Undecidability
Halting Problem = {<M,I>  M halts on I} is undecidable Will prove: {<M,I>  M prints "Hi" at some point in computation on I} poly {<M,I>  M halts on I} poly {<M,I>  M halts on I} Hence, all are equivalent! {<M,I>  M prints "Hi" on I at some point in computation } <M,I> Reductions for Undecidability {<M,I>  M halts on I} M(I) prints "Hi" on I <M',I> M'(I) = { Run M(I) if "Hi" is printed halt Loop forever }
BUILD: Oracle for {<M,I>  M prints "Hi" on I} Yes halts GIVEN: Oracle for {<M,I>  M halts on I} {<M,I>  M prints "Hi" on I at some point in computation } <M,I> Reductions for Undecidability {<M,I>  M halts on I} M(I) does not print "Hi" <M',I> M'(I) = { Run M(I) if "Hi" is printed halt Loop forever }
BUILD: Oracle for {<M,I>  M prints "Hi" on I} No, does not halt GIVEN: Oracle for {<M,I>  M halts on I} Reductions for Undecidability
Halting Problem = {<M,I>  M halts on I} is undecidable Will prove: {<M,I>  M prints "Hi" at some point in computation on I} {<M>  M halts empty string} {<M>  M halts on every input} {<M>  M halts on some input} {<M>  L(M) is regular} {<M,M'>  I M(I)=M'(I)} There is a fixed TM M* {<I>  M* halts on I} {<M>  based on what M does, not on how it does it} poly {<M,I>  M halts on I} Hence, all are equivalent! Yes Yes Yes Yes ? ? Yes ? {<M,M'>  I M(I)=M'(I)} Reductions for Undecidability {<M,I>  M halts on I} <M,M'> M=M' on every input <M',I> ?
BUILD: Oracle for {<M,M'>  I M(I) = M'(I)} M' halts or not Oracle for on this input {<M,I>  M halts on I} GIVEN: Acceptable Acceptable Computable A computational problem/language is said to be computable/decidable/recursive iff TM M On every input the machine halts and gives the correct answer. is said to be accepted/semidecided/enumerable iff TM M On every yes input the machine halts and gives the correct answer. (A halting computation is a witness of a yes answer) On every no inputs the machine could halt and gives the correct answer or could run for ever. Acceptable Acceptable Halting Computable Is there a language that can be accepted but not computed? Halting: Given <M,I> does program halt on I? Alg: Run it.
Acceptable iff TM M On every yes input the machine halts and gives the correct answer. (A halting computation is a witness of a yes answer) On every no inputs the machine could halt and gives the correct answer or could run for ever. Acceptable Acceptable Halting Computable {<M,I>  M prints "Hi" on I} {<M>  M halts empty string} {<M>  M halts on every input} {<M>  M halts on some input} TM M* {<I>  M* halts on I} Acceptable Acceptable Halting Computable CoAcceptable Not Halting A computational problem/language is said to be coaccepted/semidecided/enumerable iff TM M On every no input the machine halts and gives the correct answer. (A halting computation is a witness of a no answer) On every yes inputs the machine could halt and gives the correct answer or could run for ever. Acceptable Acceptable {<M,I>  M does print "Hi" on I} {<M,I>  M does not print "Hi" on I} Computable CoAcceptable A computational problem/language is said to be coaccepted/semidecided/enumerable iff TM M On every no input the machine halts and gives the correct answer. (A halting computation is a witness of a no answer) On every yes inputs the machine could halt and gives the correct answer or could run for ever. Acceptable
{<M,I>  M halts on I} {<M,I>  M does not print "Hi" on I at some point in computation } <M,I> No halt <M',I> M'(I) = { Run M(I), suppressing any output Print("Hi") } BUILD: Oracle for {<M,I>  M halts on I} GIVEN:O racle for Yes, no print {<M,I>  M not print "Hi" on I} Acceptable
{<M,I>  M halts on I} {<M,I>  M does not print "Hi" on I at some point in computation } <M,I> Yes halt <M',I> M'(I) = { Run M(I), suppressing any output Print("Hi") } BUILD: Oracle for {<M,I>  M halts on I} GIVEN:O racle for No, no print {<M,I>  M not print "Hi" on I} Acceptable
{<M,I>  M halts on I} {<M,I>  M does not print "Hi" on I at some point in computation } Computable If not computable If not coacceptable If computable Not computable ???? Yes and no flipped Acceptable Palg poly Poracle
Cook Reduction: Design any algorithm for Palg using a supposed algorithm for Poracle as a subroutine. Karp Reduction: The algorithm for Palg calls that for Poracle only once Yes Yes & No No Acceptable Palg poly Poracle Karp Reduction: Yes Yes & No No We will only consider reductions of this simple form. Because they preserve acceptable/coacceptable Acceptable
{<M,I>  M halts on I} <M,I> Yes M(I) halts <M',I> M'(I) = {<M,I>  M does not print "Hi" on I at some point in computation } ? BUILD: Oracle for {<M,I>  M halts on I} Yes, no print GIVEN: Oracle for {<M,I>  M not print "Hi" on I} Acceptable Acceptable CoAcceptable Computable {<M,I>  M does {<M,I>  M does not print "Hi" on I} print "Hi" on I } The two complement problems: Are equivalent wrt being computable i.e. one is, then the other is. But not equivalent wrt being acceptable Acceptable Acceptable Computable CoAcceptable {<M,M'>  I M(I)=M'(I)} A computational problem/language is said to be accepted/semidecided/enumerable On every yes input the machine halts and gives the correct answer. On every no inputs the machine could halt and gives the correct answer or could run for ever. Acceptable Acceptable Computable CoAcceptable {<M,M'>  I M(I)=M'(I)} A computational problem/language is said to be coaccepted/semidecided/enumerable On every no input the machine halts and gives the correct answer. On every yes inputs the machine could halt and gives the correct answer or could run for ever. Reductions for Undecidability Now that we have established that the Halting Problem and its friends are undecidable, we can use it for a jumping off point for more "natural" undecidability results. The Post Correspondence Problem The input is a finite collection of dominos P= b a ca abc ca , ab , a , c A solution is a finite sequence of the dominos (with repeats) a b ca a abc ab ca a ab c So that the combined string on the top is the same as that on the bottom abcaaabc abcaaabc PCP = {<P>  P is a collection of dominos with a solution} PCP is undecidable The Post Correspondence Problem
{<M,I>  M halts on I} {<P>  Dominos P has a solution} <M,I> Yes M(I) halts <P> Dominos in P mimic the rules of the TM M on input I
BUILD: Yes, there is a solution GIVEN: Oracle for {<M,I>  M halts on I} Oracle for {<P>  Dominos P has a solution} The Post Correspondence Problem Consider some configuration of a TM q
1 0 1 1 0 1 0 Encode configuration of the TM as a string giving the contents of the tape and the current state inserted where the head is.
10qi10010 The Post Correspondence Problem Consider some configuration of a TM q
1 0 1 1 0 1 0 Encode the halting computation of M on I as the string of configurations separated by `#'
#qstart0110010#1q3010010#10q710010#100q60010#10 .... #qaccept# I TM accepts by halting in the accept state with the tape empty The Post Correspondence Problem Consider some configuration of a TM q
1 0 1 1 0 1 0 Encode the halting computation of M on I as the string of configuration separated by `#'
#qstart0110010#1q3010010#10q710010#100q60010#10 .... #qaccept# M halts on I iff there is such a computation string iff the dominos P has a solution with this string as the combined string on the top and on the bottom The Post Correspondence Problem Consider some configuration of a TM q
1 0 1 1 0 1 0 The first domino in P is
# #qstart0110010# I Lets temporarily assume that the domino solution must start with this domino. The loop invariant is that in the only domino solution the combined string so far on the top consists of the first t TM configurations and on the bottom the first t+1. The Post Correspondence Problem Consider some configuration of a TM q
1 0 1 1 0 1 0 qj TM is in state qi and sees a 1. Transition (qi,1) = <qj,c,right>
1 0 c 1 0 1 0 Config: #10qi11010# #10qj11010# #10qjc1010# #10cqj1010# qi1 Related domino: cqj The Post Correspondence Problem Consider some configuration of a TM q
1 0 1 1 0 1 0 qj TM is in state qi and sees a 1. Transition (qi,1) = <qj,c,left>
1 0 c 1 0 1 0 Config: #10qi11010# #10qj11010# #10qjc1010# #1qj0c1010# Related dominos: 0qi1 1qi1 & qj0c qj1c The Post Correspondence Problem Consider some configuration of a TM q
1 0 1 1 0 1 0 Related dominos: 0 b 1 Copy unchanged characters: , ,& b 0 1 # Start a new configuration: # b# # Add and removing trailing blanks: b# & # qaccept## Accepting: # The Post Correspondence Problem The loop invariant is that in the only domino solution the combined string so far on the top consists of the first t TM configurations and on the bottom the first t+1. ...0# ...0#10qi1001b# The Post Correspondence Problem For the top string to match the bottom string this t+1st configuration must be produced by dominos on the top. ...0# 1 ...0#10qi1001b# 0 qi1 0 0 1 b # The Post Correspondence Problem With With transition (qi,1) = <qj,0,right> the only way to match the "qi1" on top is with the domino Then the remain characters can be copied down. ...0# 1 ...0#10qi1001b# 1 0 qi1 0 0 0qj 0 0 0 1 1 b b # # The Post Correspondence Problem This maintains the loop invariant that in the only domino solution the combined string so far on the top consists of the first t TM configurations and on the bottom the first t+1. ...0# 1 0 qi1 0 0 1 ...0#10qi1001b# 1 0 0qj 0 0 1 ...0#10qi1001b# ...0#10qi1001b#100qj001b# b b # # The Post Correspondence Problem The TM is allowed to use as much tape as it likes. The extra cells are assumed to initially contain blanks. Towards this end, suppose you would like to insert a blank at the end of this configuration before the #. ...0# 1 ...0#10qi1001b# 1 ...0# 1 ...0#10qi1001b# 1 0 qi1 0 0 0qj 0 0 qi1 0 0 0qj 0 0 0 0 0 1 1 1 1 b b # # b # b b# This also maintains the loop invariant ...0#10qi1001b# ...0#10qi1001b#100qj001bb# The Post Correspondence Problem The TM is expected to leave the tape containing only blanks before it halts. Suppose towards that goal, you would like to delete that last trailing blank. ...0# 1 ...0#10qi1001b# 1 ...0# 1 ...0#10qi1001b# 1 0 qi1 0 0 0qj 0 0 qi1 0 0 0qj 0 0 0 0 0 1 1 1 1 b b b # # # # This also maintains the loop invariant ...0#10qi1001b# ...0#10qi1001b#100qj001# Hence the LI is always maintained. The Post Correspondence Problem Suppose the TM halts and accepts after t+1 time steps, then the first t+1 TM configurations end like this: ...0#qaccept# The loop invariant is that in the only domino solution the combined string so far on the top consists of the first t TM configurations and on the bottom the first t+1. The Post Correspondence Problem We know that this loop invariant has been maintained Hence, we know that the only domino solution ends like this: ...0# ...0#qaccept# The loop invariant is that in the only domino solution the combined string so far on the top consists of the first t TM configurations and on the bottom the first t+1. The Post Correspondence Problem To this we can add a last domino to complete the solution ...0# qaccept## ...0#qaccept# # ...0#qaccept## ...0#qaccept## And this completes the solution with the combined string on the top being the same as that on the bottom. The Post Correspondence Problem Consider some configuration of a TM q
1 0 1 1 0 1 0 ...0#qaccept## ...0#qaccept## Of course such a solution is impossible, if TM M does not halt and accept input I. I The Post Correspondence Problem Consider some configuration of a TM q
1 0 1 1 0 1 0 The first domino in P is
# #qstart0110010# I Lets temporarily assume that the domino solution must start with this domino. We now need to consider the problem with this restriction removed. The Post Correspondence Problem Consider these dominos
# #qstart0110010# , 1qi1 qi1 0qi1 cqj , qj0c , qj1c , qaccept## 0 b # 1 b# # 0 , 1 , b , # , b# , # , & # A solution is a finite sequence of the dominos (with repeats) so that the combined string on the top is the same as that on the bottom Can you find a nice easy solution? 0 0 The Post Correspondence Problem Insert *s into the dominos
*# *#*qstart*0*1*1*0*0*1*0*#* *qi*1 *0*qi*1 *1*qi*1 , c*q * , qj0c* , qj*1*c*, j *qaccept*#*#* *b*# *# *0 *b *# *1 0* , 1* , b* , #* , b*#* , #* , & #* A solution is a finite sequence of the dominos (with repeats) so that the combined string on the top is the same as that on the bottom Can you now find a nice easy solution? This first domino must go first because it is the only one with its first character on top and bottom the same. The Post Correspondence Problem Insert *s into the dominos
*# *#*qstart*0*1*1*0*0*1*0*#* *qi*1 *0*qi*1 *1*qi*1 , c*q * , qj0c* , qj*1*c*, j *qaccept*#*#* *b*# *# *0 *b *# *1 0* , 1* , b* , #* , b*#* , #* , & #* A solution is a finite sequence of the dominos (with repeats) so that the combined string on the top is the same as that on the bottom The rest of the proof is the same, producing:
*#*qstart*0*1*1*0*0*1*0*#*1*...q3*0*1*0*0* .... *#*qaccept*#* *#*qstart*0*1*1*0*0*1*0*#*1*...q3*0*1*0*0* .... *#*qaccept*#* The Post Correspondence Problem
{<M,I>  M halts on I} {<P>  Dominos P has a solution} <M,I> Yes M(I) halts <P> Dominos in P mimic the rules of the TM M on input I
BUILD: Yes, there is a solution GIVEN: Oracle for {<M,I>  M halts on I} Oracle for {<P>  Dominos P has a solution} Done Tiling Problem The input is a finite collection of tiles A solution is a tiling of a finite square with these tiles without rotating them. (with repeats) Tiling = {<>  is a collection tiles with a solution} Tiling is undecidable Tiling Problem {<M,I>  M halts on I} {<>  Tiles have a solution} <M,I> Yes M(I) halts <> Tiles in mimic the rules of the TM M on input I
BUILD: Yes, there is a solution GIVEN: Oracle for {<M,I>  M halts on I} Oracle for {<>  Tiles have a solution} Tiling Problem Consider some configuration of a TM q
1 0 1 1 0 1 0 Encode configuration of the TM as a string giving the contents of the tape and the current state inserted where the head is.
10qi10010 Tiling Problem Consider some configuration of a TM q
1 0 1 1 0 1 0 Encode the halting computation of M on I with time T as a list configurations on separate lines padded with blanks to form a square.
################### #qstart 0110010bbbbbbb# #1q3010010bbbbbbbbb# #10q710010bbbbbbbbb# #100q60010bbbbbbbbb# #10 .... bbbbbbbbbbbb# #qacceptbbbbbbbbbbbbb# Form a collection of tiles to capture the ways that these characters can fit together. Context Free Grammars
Halting Problem = {<M,I>  M halts on I} is undecidable Will prove: {<G,I>  CFG generates I} {<G>  CFG G generates every string} {<G>  CFG G generates no string} {<G,G'>  L(G) = L(G')} O(n3) time ? poly {<M,I>  M halts on I} Hence, all are undecidable! CFG G Generates I
(Parsing) T AB CA TT A AA BT a Input: T a1a2a3 ..... an B TA BC b e C CB AC c d T C A Ask Little Bird: For first rule For the split. b a e a a d b b d a CFG G Generates I
(Parsing) T AB CA TT A AA BT a Input: T a1a2a3 ..... an B TA BC b e C CB AC c d T C A A B T A B b a e a a d b b d a A C A C C B A Ask left friend: Instance: C baeaadb Solution: Left parsing CFG G Generates I
(Parsing) T AB CA TT A AA BT a Input: T a1a2a3 ..... an B TA BC b e C CB AC c d T C A B T C A Ask right friend: Instance: A bda Solution: Right parsing b a e a a d b b d a CFG G Generates I
(Parsing) T AB CA TT A AA BT a Input: T a1a2a3 ..... an B TA BC b e C CB AC c d T C A A B T A B b a e a a d b b d a A C A C C B A B T C A Combine: Instance: Bird's Answer Left Friend's Answer Right Friend's Answer CFG G Generates I
(Parsing) Running time = ( # of subinstances # bird answers ) = ( # of nonterminals n2 # of rules n ) subInstances: T' aiai+1 ..... aj nonterminals T' gives: First rule and split & i,j [1,n] Done CFG Generates Everything
Halting Problem = {<M,I>  M halts on I} is undecidable Will prove: {<G,I>  CFG generates I} {<G>  CFG G generates every string} {<G>  CFG G generates no string} {<G,G'>  L(G) = L(G')} O(n3) time Undecidable ? poly {<M,I>  M halts on I} Hence, all are undecidable! CFG Generates Everything
{<M,I>  M halts on I} {<G>  CFG G generates every string} <M,I> No, M(I) does not halt <G> Grammar G rules mimic the rules of the TM M on input I
BUILD: Oracle for Yes, there is a parsing of everything GIVEN: Oracle for {<M,I>  M halts on I} {<G>  CFG G generates every string} CFG Generates Everything
{<M,I>  M halts on I} {<G>  CFG G generates every string} <M,I> Yes, M(I) does halt <G> Grammar G rules mimic the rules of the TM M on input I
BUILD: Oracle for No, the string GIVEN: corresponding to the computation cant be parsed Oracle for {<G>  CFG G generates every string} {<M,I>  M halts on I} CFG Generates Everything Consider some configuration of a TM q
1 0 1 1 0 1 0 Encode configuration of the TM as a string giving the contents of the tape and the current state inserted where the head is.
10qi10010 CFG Generates Everything Consider some configuration of a TM q
1 0 1 1 0 1 0 Encode the halting computation of M on I as the string of configurations separated by `#'
#qstart0110010#1q3010010#10q710010#100q60010#10 .... #qaccept# TM accepts by halting in the I accept state with the tape empty CFG Generates Everything Consider some configuration of a TM q
1 0 1 1 0 1 0 Encode the halting computation of M on I as the string of configurations separated by `#'
#qstart0110010#1q3010010#10q710010#100q60010#10 .... #qaccept# # Linked because must be the same string Linked because must be the same string Can a CFG generate this string? No CFG Generates Everything Consider some configuration of a TM q
1 0 1 1 0 1 0 Encode the halting computation of M on I as the string of configurations separated by `#'
#qstart0110010#1q3010010#10q710010#100q60010#10 .... #qaccept# # Can a CFG generate every string but this string? Yes CFG Generates Everything Consider some configuration of a TM q
1 0 1 1 0 1 0 Encode the halting computation of M on I as the string of configurations separated by `#'
#qstart0110010#1q3010010#10q710010#100q60010#10 .... #qaccept# M halts on I there is such a computation string CFG can generate every string but this string CFG does not generate every string Oracle says no CFG Generates Everything Consider some configuration of a TM q
1 0 1 1 0 1 0 Encode the halting computation of M on I as the string of configurations separated by `#'
#qstart0110010#1q3010010#10q710010#100q60010#10 .... #qaccept# M does not halt on I there is no such a computation string CFG can generate every string Oracle says yes CFG Generates Everything Consider some configuration of a TM q
1 0 1 1 0 1 0 Encode the halting computation of M on I as the string of configurations separated by `#'
#qstart0110010#1q3010010#10q710010#100q60010#10 .... #qaccept# A string is not this string if at least one of: It It does not start with #qstartI# It It does not end with #qaccept# Some Some time step #10q710010#100q60010# is not according to the TM M. CFG Generates Everything Consider some configuration of a TM q
1 0 1 1 0 1 0 Some time step is not according to the TM M. {0,1}* #10q710010#100q60010# {0,1}*
This is correct, but we need it to be wrong Not according to the TM M if at least one of: Not Not (#{0,1}*qi{0,1}*)*# Transition rule incorrect. Early unchanged tape not copied correctly Late unchanged tape not copied correctly CFG Generates Everything Consider some configuration of a TM q
1 0 1 1 0 1 0 Early unchanged tape not copied correctly {0,1}* #10q710010#100q60010# {0,1}*
{0,1}* # {0,1}i 0 {0,1}*{qi}{0,1}*# {0,1}i 1{0,1}*{qi}{0,1}*#{0,1}* Linked because same size S' B S' A# A CA  C 0  1 B CBC 0A{qi}A# B A 1A {qi} A # A The rest is similar CFG Generates Everything
{<M,I>  M halts on I} {<G>  CFG G generates every string} <M,I> No, M(I) does not halt <G> Grammar G rules mimic the rules of the TM M on input I
BUILD: Oracle for Yes, there is a parsing of everything GIVEN: Oracle for {<M,I>  M halts on I} {<G>  CFG G generates every string} CFG G Generates Some String
Halting Problem = {<M,I>  M halts on I} is undecidable Will prove: {<G,I>  CFG generates I} {<G>  CFG G generates every string} {<G>  CFG G generates no string} {<G,G'>  L(G) = L(G')} O(n3) time Undecidable O(~n) time ? poly {<M,I>  M halts on I} Hence, all are undecidable! CFG G Generates Some String Input: CFG G Output: Whether generates any string Algorithm by example G = S abAcdSaaAef  acAadBddAa  cCdAe A aaAbbBb  baBcd B aaBssSsa  funwow  aAbCc C ccCcSdAd  efCghAqSr  bBbAbBb Does this G generate any string? G= S abAcdSaaAef  acAadBddAa  cCdAe A aaAbbBb  baBcd B aaBssSsa  funwow  aAbCc C ccCcSdAd  efCghAqSr  bBbAbBb We only care if G generates some string. We don't care which. Delete all terminals G2 = S ASA  ABA  CA A AB  B B BS   AC C CSA  CAS  BAB G generates some string iff G2 generates . CFG G Generates Some String G2 = S ASA  ABA  CA A AB  B B BS   AC C CSA  CAS  BAB Does G2 generate ? We need a parsing that gets rid of all nonterminals. Nonterminal B can be replaced with . Why ever use the rule B AC instead of B G3 = S ASA  ABA  CA A AB  B B C CSA  CAS  BAB G2 generates iff G3 generates . CFG G Generates Some String G3 = S ASA  ABA  CA A AB  B B C CSA  CAS  BAB Does G3 generate ? Lets just plug in B G4 = S ASA  AA  CA A A  C CSA  CAS  A CFG G Generates Some String G3 generates iff G4 generates . G4 = S ASA  AA  CA A A  C CSA  CAS  A CFG G Generates Some String Does G4 generate ? Why use A A instead of A Lets just plug in A G5 = S S   C C CS  CS  G4 generates iff G5 generates . CFG G Generates Some String G5 = S S   C C CS  CS  Does G5 generate ? Yes using S Hence, G generates some string! CFG G Generates Some String Input: CFG G Output: Whether generates any string Algorithm by another example G = S abAcdSaaAef  acAadBddAa  cCdAe A aaAbbBb  baBcd B aaBssSsa  aAbCc C ccCcSdAd  efCghAqSr  bBbAbBb Does this G generate any string? G= S abAcdSaaAef  acAadBddAa  cCdAe A aaAbbBb  baBcd B aaBssSsa  aAbCc C ccCcSdAd  efCghAqSr  bBbAbBb We only care if G generates some string. We don't care which. Delete all terminals G2 = S ASA  ABA  CA A AB  B B BS  AC C CSA  CAS  BAB G generates some string iff G2 generates . CFG G Generates Some String G2 = S ASA  ABA  CA A AB  B B BS  AC C CSA  CAS  BAB Does G2 generate ? The number nonterminals in our string never goes down G2 does not generate . Hence, G does not generate any strings! CFG G Generates Some String L(G) = L(G')
Halting Problem = {<M,I>  M halts on I} is undecidable Will prove: {<G,I>  CFG generates I} {<G>  CFG G generates every string} {<G>  CFG G generates no string} {<G,G'>  L(G) = L(G')} O(n3) time Undecidable O(~n) time Undecidable ? poly {<M,I>  M halts on I} Hence, all are undecidable! L(G) = L(G')
{<G>  CFG G generates every string} {<G,G'>  L(G) = L(G')} <G> Yes, G generates every string <G,G'> G' = S AS  A 0 1
BUILD: Yes, L(G) = L(G') GIVEN: Oracle for {<G>  CFG G generates every string} Oracle for {<G,G'>  L(G) = L(G')} Context Free Grammars
Halting Problem = {<M,I>  M halts on I} is undecidable Will prove: {<G,I>  CFG generates I} {<G>  CFG G generates every string} {<G>  CFG G generates no string} {<G,G'>  L(G) = L(G')} O(n3) time Undecidable O(~n) time Undecidable poly {<M,I>  M halts on I} Hence, all are undecidable! Game of Life The Game of Life: Grid of square cells, each live or dead. The initial pattern is the seed of the system. At each step in time, every live cell # live neighbours {2,3} dies every dead cell # live neighbours = 3 comes alive Game of Life The Game of Life: Grid of square cells, each live or dead. The initial pattern is the seed of the system. At each step in time, every live cell # live neighbours {2,3} dies every dead cell # live neighbours = 3 comes alive Life Problem: Input: An initial configuration Output: Does it go on forever? Undecidable! I would love to see the proof. Hilbert's 10th Problem Input: a multivariate polynomial 2x2y8z3 + 7x3y2  8x4y2z5 = 0 Output: Does it have integer values giving zero? Undecidable! Proof not hard. Maybe we will cover it. The End ...
View
Full
Document
This note was uploaded on 02/13/2012 for the course CSE 4111 taught by Professor Edmonds during the Winter '12 term at York University.
 Winter '12
 Edmonds

Click to edit the document details