Jeff Edmonds York University COSC 4111 Lecture 4 Different ModelsDifferent ModelsDifferent ModelsDifferent Models ReductionsReductionsReductions Simple

Jeff EdmondsYork University COSC 4111

Lecture 4

• Different Models• Reductions• Simple Reductions• Rice's Theorem• Acceptable• Acceptability Complete

Reductions to the Halting Problem

• 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

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}

n, circuit computed in time size(n)Every human dies.

?

Every primitive recursive program halts.

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.


≤Oracle Alg

Assume have an alg.Design an alg.

Reductions

But there is likely not a fast algorithm for

either!!!

Reductions Iharder

Iharder yes

Pharder

Iharder no

Ieasier

Ieasier yes

Peasier

Ieasier no

Two problems/languages Peasier and Pharder

each with their own definitions of• what a legal input is (Ieasier vs Iharder) and • which are yes-inputs and which no-inputs.

Reductions Iharder

Iharder yes

Pharder

Iharder no

Ieasier

Ieasier yes

Peasier

Ieasier no

We want machines that decide/accept them.

Algharder

Pharder(Iharder)IharderPeasier(Ieasier)Ieasier

Algeasier

ReductionsPeasier ≤comp Pharder

Iharder

Iharder yes

Pharder

Iharder no

Ieasier

Ieasier yes

Peasier

Ieasier no

How do their complexities/difficulties

compare?

Computable/Decidable

Exp

Poly

NP Co-NP

Recognizable Co-Recognizable

ReductionsPeasier ≤comp Pharder

Iharder

Iharder yes

Pharder

Iharder no

Ieasier

Ieasier yes

Peasier

Ieasier no

It is hard to prove problem is Pharder hard.

It is easier to prove Peasier is easy.

• by design an algorithm Algeasier for it.

But you only need to prove Peasier is at least as easy as Pharder .

• Pretend you have an algorithm Algharder for Pharder

to use as a subroutine.

ReductionsPalg ≤comp Poracle

Ioracle

Ioracle yes

Poracle

Ioracle no

Ialg

Ialg yes

Palg

Ialg no

We often call the algorithm assumed to exist, an Oracle. Given

Algoracle

Poracle(Ioracle)Ioracle


Ioracle

Ioracle yes

Poracle

Ioracle no

Ialg

Ialg yes

Palg

Ialg no

We use Algoracle as an subroutinein an algorithm Algalg for solving Palg.

GivenAlgoracle

Poracle(Ioracle)Ioracle

BuildAlgAlg

Palg(Ialg)

Ialg


IoracleIalg

Ialg

Algalg is given an input Ialg.

GivenAlgoracle

Poracle(Ioracle)IoracleIoracle = InstanceMap(Ialg)

BuildAlgAlg

Palg(Ialg)

Ialg

InstanceMap

Ioracle

It maps it to input Ioracle.and gives this to Algoracle.


IoracleIalg

Ialg

Algoracle gives the yes/no answer for his input Ioracle.

GivenAlgoracle


BuildAlgAlg

Palg(Ialg)

Ialg

Return same answer yesyes no no

InstanceMap

Ioracle yes

Poracle

Ioracle no

Algalg returns the same answer.


IoracleIalg

To ensure Algalg works, Ioracle = InstanceMap(Ialg) must

GivenAlgoracle


BuildAlgAlg

Palg(Ialg)

Ialg


InstanceMap

Ioracle yes

Poracle

Ioracle no

Ialg yes

Palg

Ialg no

map yes instances to yes instances and no to no.


IoracleIalg

Must prove Algalg works.

GivenAlgoracle


BuildAlgAlg

Palg(Ialg)

Ialg


InstanceMap

Ioracle yes

Poracle

Ioracle no

Ialg yes

Palg

Ialg no

Ialg is a yes input Ioracle

is a yes input Algoracle

says yes Algalg says yes


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

Palg ≤comp Poracle

GIVEN:Network

Flow Oracle

BUILD:Matching

Oracle

Matching ≤comp Network Flows

Who loves whoAnnFred

SueJohn

BethBob

MarySam

Max matching

A network

s t

Max Flow

s t

Reductions

• Learn that a new problem is likely hard, from knowing a known problem is likely hard.

Reductions

HaltingComputable

Exp

Poly

Is there an algorithm for Poracle?Is there an algorithm for Palg?

?

We give an algorithm for Palg using a supposed algorithm for Poracle as a subroutine.

Reductions

If there is an algorithm for Palg

then there is an algorithm for Palg

then there is not fast

algorithm for Poracle

If there is not an algorithm for Palg

If there is an algorithm for Poracle

If there is not an algorithm for Poracle

?

?


?

???

??

Reductions

Notation: Palg ≤comp Poracle

Palg is “at least as easy as” Poracle

(Modulo polynomial terms.)

Poracle is “at least as hard as” Palg

(Modulo polynomial terms.)

Conclusions:


Reductions


Halting Problem = {<M,I> | M halts on I} is undecidable

• {<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* { | M* halts on I}• {<M> | based on what M does, not on how it does it}

Will prove:

≥comp {<M,I> | M halts on I}Hence, all are undecidable!

• {<M,I> | M prints “Hi” at some point in computation on I}comp {<M,I> | M halts on I}

Hence, equivalent.• {<M,I> | M halts on I} comp {<M,I> | M does not halt on I} ?


GIVEN:

Oracle for

<M,I>

BUILD:

Oracle for

<M',I>

{<M,I> | M halts on I} {<M,I> | M prints “Hi” on I}

{<M,I> | M prints “Hi” on I at some point in computation }

M(I) halts

Yes, prints “Hi”

{<M,I> | M halts on I} ≤

M'(I) = { M is built in Run M(I), Print(“Hi”) }

suppressing any output


GIVEN:

Oracle for

<M,I>

BUILD:

Oracle for

<M',I>

{<M,I> | M halts on I} {<M,I> | M prints “Hi” on I}

{<M,I> | M halts on I} ≤ {<M,I> | M prints “Hi” on I at some point in computation }

M(I) does not halt

No “Hi”

M'(I) = { M is built in Run M(I), Print(“Hi”) }



<M,I> <M'I>

{<M,I> | M halts on I} {<M> | M halts empty string}

{<M,I> | M halts on I} ≤ {<M> | M halts empty string}

M(I) halts or not

M'I(I’) = { Ignore input I' M & I are built in Run M(I) }

Yes or NoGIVEN:

Oracle forBUILD:

Oracle for


<M,I> <MI>

{<M,I> | M halts on I} {<M> | M halts on every input}

{<M,I> | M halts on I} ≤ {<M> | M halts on every input}

M(I) halts or not

MI(I') = { Ignore input I' M & I are built in Run M(I) }

Yes or NoGIVEN:

Oracle forBUILD:

Oracle for


<M,I> <MI>

{<M,I> | M halts on I} {<M> | M halts on some input}

{<M,I> | M halts on I} ≤ {<M> | M halts on some input}

M(I) halts or not

MI(I') = { Ignore input I' M & I are built in Run M(I) }

Yes or NoGIVEN:

Oracle forBUILD:

Oracle for


Wait until we do Rice’s Theorem

Wait until we do Rice’s Theorem


<M,I> <MI>

{<M,I> | M halts on I}


M(I) halts or not

MI(I') = { Ignore input I' M & I are built in Run M(I)

Yes or NoGIVEN:

Oracle forBUILD:

Oracle for

{<M> | L(M) is regular}

{<M> | L(M) is regular}

But now we care about what M(I) outputs when it halts.


Halt and accept }


<M,I> <MI>

{<M,I> | M halts on I} {<M> | L(M) is regular}

{<M,I> | M halts on I} ≤ {<M> | L(M) is regular}

M(I) halts

L(MI) = {everything} Yes , L(MI) is regular

GIVEN:

Oracle forBUILD:

Oracle for

MI(I') = { Ignore input I' M & I are built in Run M(I)


Halt and accept }


<M,I> <MI>



M(I) does not halt

L(MI) = {nothing}Yes, L(MI) is regular

GIVEN:

Oracle forBUILD:

Oracle for

MI(I') = { Ignore input I' M & I are built in Run M(I) Halt and accept }



<M,I>



GIVEN:

Oracle forL(MI) = No, L(MI) is not regular

BUILD:

Oracle for 0n1n

M(I) does not halt

MI accepts 0n1n, but “computes” no language

<MI>MI(I') = { If I’ has the form 0n1n

halt and accept else run M(I) halt and accept }



<M,I>

<MI>



GIVEN:

Oracle forL(MI) = Yes, L(MI) is regular

BUILD:

Oracle for {everything}

M(I) halts

<MI>MI(I') = { If I’ has the form 0n1n

halt and accept else run M(I) halt and accept }



<M,I> <MI,M'>

{<M,I> | M halts on I} {<M,M'> | I M(I)=M'(I)}

{<M,I> | M halts on I} ≤ {<M,M'> | I M(I)=M'(I)}

M(I) halts or not

Same or differentGIVEN:

Oracle forBUILD:

Oracle for

MI(I') = M' = ? { Ignore input I' M & I are built in Run M(I) Halt and accept }



<MI,M'>

If M halts on I MI halts on and accepts every input MI and M' have the same results on every input Oracle says yes We say yes


M'(I') halts and acceptsMI(I') = M' = ? { Ignore input I' M & I are built in Run M(I) Halt and accept }



<MI,M'>

If M does not halt on I MI does not halt on every input MI and M' have different results on some input Oracle says no We say no




M'(I') halts and accepts


<M,I> <MI,M'>

{<M,I> | M halts on I} {<M,M'> | I M(I) = M'(I)}


M(I) halts or not

Yes or No GIVEN:

Oracle forBUILD:

Oracle for



M'(I') halts and accepts


<M,I> <I'>

{<M,I> | M halts on I} { | M* halts on I}

{<M,I> | M halts on I} ≤ { | M* halts on I}where M* is a special TM

M(I) halts or not

Need to tell oracle about M and II' = <M,I>M* is the universal TM simulates M on I.

Yes or NoGIVEN:

Oracle forBUILD:

Oracle for

Reductions for Undecidability{<M,I> | M halts on I} ≤ P = {<M> | L(M) has property …

ie based on what M does, not on how it does it}

If L(M) =L(M'), then MϵP iff MϵP'

P ≠ {everything}P ≠ {nothing}

Rice’s Theorem

P is undecidable.

Eg P = {<M> | L(M) is regular}

Eg P = {<M> | M(010) = yes and M(1001) = no or M(101) = no }

Reductions for Undecidability{<M,I> | M halts on I} ≤

(Else switch to P)

Assume Myes ϵ P

Let Mempty = just say no.L(Mempty) = {nothing}Assume Mempty P,

Proof:

P = {<M> | L(M) has property … ie based on what M does, not on how it does it}

If L(M) =L(M'), then MϵP iff MϵP'

P ≠ {everything}P ≠ {nothing}

Rice’s Theorem

P is undecidable.


GIVEN:

Oracle for

<M,I>

BUILD:

Oracle for

<M'>

{<M,I> | M halts on I} P


M(I) halts

M'(I') = { Run M(I) Run Myes(I') respond as Myes(I') does }

Yes

P = {<M> | based on what M does, not on how it does it}

L(M') = L(Myes) Myes ϵ P M' ϵ P


GIVEN:

Oracle for

<M,I>

BUILD:

Oracle for

<M'>

{<M,I> | M halts on I} P


M(I) does not halt

M'(I') = { Run M(I) Run Myes(I') respond as Myes(I') does }

No

P = {<M> | based on what M does, not on how it does it}

L(M') = {nothing} = L(Mempty) Mempty ϵ P M' ϵ P


<M,I> <M',I>

{<M,I> | M halts on I}{<M,I> | M prints “Hi” on I}

≤ {<M,I> | M halts on I}{<M,I> | M prints “Hi” on I at some point in computation }

M(I) prints “Hi” on I

M'(I) = { Run M(I) if “Hi” is printed halt Loop forever }

Yes haltsGIVEN:

Oracle forBUILD:

Oracle for

Other direction


GIVEN:

Oracle for

<M,I>

BUILD:

Oracle for

<M',I>


≤ {<M,I> | M halts on I}{<M,I> | M prints “Hi” on I at some point in computation }

M(I) does not print “Hi”

M'(I) = { Run M(I) if “Hi” is printed halt Loop forever }

No, does not halt


• {<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* { | M* halts on I}• {<M> | based on what M does, not on how it does it}

Will prove:

≥comp {<M,I> | M halts on I}Hence, all are undecidable!

• {<M,I> | M prints “Hi” at some point in computation on I}comp {<M,I> | M halts on I}

Hence, equivalent.• {<M,I> | M halts on I} comp {<M,I> | M does not halt on I} ?

Reductions for Acceptability

<M,I>

<M,I>

{<M,I> | M does not halt on I}{<M,I> | M halts on I}

≤ {<M,I> | M does not halt on I}

No: Does not halt

Yes: Does not halt.GIVEN:

Oracle forBUILD:

Oracle for

{<M,I> | M halts on I}Reductions for Acceptability

<M,I>

<M,I>


≤ {<M,I> | M does not halt on I}

Yes: Does halt

No: Does halt.GIVEN:

Oracle forBUILD:

Oracle for

{<M,I> | M halts on I}

Wait! Is this allowed?



Karp Reduction: Yes Yes & No No

Cook Reduction: Design any algorithm for Palg using a supposed algorithm for Poracle as a subroutine.


Wait! Is this allowed?

• Yes instance Halt and answer “yes”• No instance

Run forever or answer “no”

Acceptable• Yes instance

Run forever or answer “yes”• No instance

Halt and answer “no”

Computable• Yes instance

Halt and answer “yes”• No instance


Co-Acceptable

Halting Halting



Karp Reduction: Yes Yes & No No

Cook Reduction: Design any algorithm for Palg using a supposed algorithm for Poracle as a subroutine.


We will only consider reductions of this simple form.Because they preserve acceptable/co-acceptable






Co-Acceptable

Halting


Halting

• {<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* { | M* halts on I}

Halting






Co-Acceptable

Halting


Halting

{<M> | L(M) is regular}{<M,M'> | I M(I)=M'(I)}

Halting ≤ Halting ≤



Acceptable

Halting

Acceptability Complete

Defn: Problem Pcomplete is Acceptability Complete iff

• Pcomplete Acceptability

• P Acceptability, P ≤comp Pcomplete

I.e. Pcomplete is one of the hardest problems in Acceptability.If we had an algorithm for Pcomplete, then we would have one for every problem in Acceptability.Claim: Halting is Acceptability Complete.

Pcomplete



Acceptable

Halting


Claim: Halting is Acceptability Complete.• Halting Acceptability• P Acceptability, There is a TM MP such that

We must now prove P ≤comp Halting


I<MI,0>I P

MI(I’) = { Run MP(I)

If halt and accept halt and accept else run forever }

HaltsGIVEN:

Oracle forBUILD:

Oracle for

≤ {<M,I> | M halts on I}P

P {<M,I> | M halts on I}


II P

MI(I’) = { Run MP(I)

If halt and accept halt and accept else run forever }

Runs foreverGIVEN:

Oracle forBUILD:

Oracle for

≤ {<M,I> | M halts on I}P

P {<M,I> | M halts on I}

<MI,0>



Acceptable

Halting


Claim: Halting is Acceptability Complete.• Halting Acceptability• P Acceptability, There is a TM MP such that

We proved P ≤comp Halting

Acceptable

Halting


Claim: They all are Acceptability Complete.• They Acceptability• P Acceptability,

We proved P ≤comp Halting ≤comp These problems

• {<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* { | M* halts on I}

Acceptable

Halting


Claim: This is Acceptability Hard, but not Complete.• This Acceptability• P Acceptability,

We proved P ≤comp Halting ≤comp This problem

{<M> | L(M) is regular}{<M,M'> | I M(I)=M'(I)}


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 dominoes

• A solution is a finite sequence of the dominoes (with repeats)

bca

aab

caa

abcc

aab

• So that the combined string on the top is the same as that on the bottom

a b c a a a b ca b c a a a b c

• PCP = { | P is a collection of dominoes with a solution}

bca ,

aab ,

caa ,

abccP =

• PCP is undecidable

GIVEN:

Oracle for

<M,I>

BUILD:

Oracle for

{<M,I> | M halts on I} { | Dominos P has a solution}

{<M,I> | M halts on I} ≤ { | Dominos P has a solution}

Yes M(I) halts

Dominos in P mimic

the rules of the TM M on input I

Yes, there is a solution

The Post Correspondence Problem

• 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 ProblemConsider some configuration of a TM

101 1 0 1 0q

• Encode the halting computation of M on I as the string of configurations separated by ‘#’

#qstart0110010#1q3010010#10q710010#100q60010#10 …. #qaccept#

I


101 1 0 1 0q

TM accepts by halting in the accept state with the tape empty

• Encode the halting computation of M on I as the string of configuration separated by ‘#’



101 1 0 1 0q

M halts on I iff there is such a computation stringiff the dominoes P has a solution with this string as the combined string on the top and on the bottom

• The first domino in P is


101 1 0 1 0q

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


101 1 0 1 0q

Transition (qi,1) = <qj,c,right>

#10qi11010#Config:

TM is in state qi and sees a 1.

c01 1 0 1 0

qj

#10qj11010#

#10qjc1010##10cqj1010#

Related domino: qi1cqj

Transition (qi,1) = <qj,c,left>

#10qi11010#Config:

TM is in state qi and sees a 1.

c01 1 0 1 0

qj

#10qj11010#

#10qjc1010##1qj0c1010#

Related dominoes:0qi1 qj0c

1qi1 qj1c

&

Consider some configuration of a TM

101 1 0 1 0q


Related dominoes:


101 1 0 1 0q

• Add and removing trailing blanks:

• Start a new configuration:

• Copy unchanged characters:

##

qaccept###

• Accepting:


,00

11 , &

bb

# b#

b# #&

The Post Correspondence Problem• The loop invariant is that in the only domino solution• the combined string so far on the top


…0#

…0#10qi1001b#

The Post Correspondence Problem• For the top string to match the bottom string

this t+1st configuration must be produced by dominoes on the top.

…0#

…0#10qi1001b# 01 qi1 0 0 1 b #

The Post Correspondence Problem• 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#

…0#10qi1001b# 01 qi1 0 0 1 b #

0qj01 0 0 1 b #

The Post Correspondence Problem• This maintains the loop invariant that

in the only domino solution• the combined string so far on the top


…0#

…0#10qi1001b# 00

11

qi10qj

…0#10qi1001b#

…0#10qi1001b#100qj001b#

00

00

11

bb

##

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#

…0#10qi1001b# 01 qi1 0 0 1 b #

0qj01 0 0 1 b #

…0#

…0#10qi1001b# 01 qi1 0 0 1 b

0qj01 0 0 1 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#

…0#10qi1001b# 01 qi1 0 0 1 b #

0qj01 0 0 1 b #

…0#

…0#10qi1001b# 01 qi1 0 0 1

0qj01 0 0 1b #

#

• This also maintains the loop invariant

…0#10qi1001b#

…0#10qi1001b#100qj001# Hence the LI is

always maintained.


…0#qaccept#

• Suppose the TM halts and accepts after t+1 time steps,then the first t+1 TM configurations end like this:

• The loop invariant is that in the only domino solution• the combined string so far on the top



…0#qaccept#

…0#

• We know that this loop invariant has been maintained• Hence, we know that the only domino solution

ends like this:

• The loop invariant is that in the only domino solution• the combined string so far on the top



…0#

…0#qaccept# qaccept##

#

…0#qaccept##

…0#qaccept##

And this completes the solution with the combined string on the topbeing the same as that on the bottom.

• To this we can add a last domino to complete the solution


…0#qaccept##

…0#qaccept##

Of course such a solution is impossible,if TM M does not halt and accept input I.


101 1 0 1 0q

• The first domino in P is


101 1 0 1 0q

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


• Consider these dominoes

##

qaccept###,

00

11 ,

bb

# b#

b# #

qi1cqj

0qi1 qj0c

1qi1 qj1c

# #qstart0110010# , , , ,

, &, , ,

• A solution is a finite sequence of the dominoes (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?

00


• Insert *s into the dominoes

*##*

*qaccept*#*#*#*,

*00*

*11* ,

*bb*

*# b*#*

*b*# #*

*qi*1c*qj*

*0*qi*1 qj0c*

*1*qi*1 qj*1*c*

*# *#*qstart*0*1*1*0*0*1*0*#* , , , ,

, &, , ,


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.


• Insert *s into the dominoes

*##*

*qaccept*#*#*#*,

*00*

*11* ,

*bb*

*# b*#*

*b*# #*

*qi*1c*qj*

*0*qi*1 qj0c*

*1*qi*1 qj*1*c*

*# *#*qstart*0*1*1*0*0*1*0*#* , , , ,

, &, , ,


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

GIVEN:

Oracle for

<M,I>

BUILD:

Oracle for

{<M,I> | M halts on I} { | Dominos P has a solution}

{<M,I> | M halts on I} ≤ { | Dominos P has a solution}

Yes M(I) halts

Dominos in P mimic




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

GIVEN:

Oracle for

<M,I>

BUILD:

Oracle for

{<M,I> | M halts on I} {<τ> | Tiles τ have a solution}

{<M,I> | M halts on I} ≤ {<τ> | Tiles τ have a solution}

Yes M(I) halts

<τ>Tiles in τ mimic



Tiling Problem


10qi10010

Tiling ProblemConsider some configuration of a TM

101 1 0 1 0q

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

Tiling ProblemConsider some configuration of a TM

101 1 0 1 0q

• Form a collection of tiles to capture the ways that these characters can fit together.

Context Free Grammars


• {<G,I> | CFG generates I}• {<G> | CFG G generates every string}• {<G> | CFG G generates no string}• {<G,G’> | L(G) = L(G’)}

Will prove:

≥comp {<M,I> | M halts on I}

Hence, all are undecidable!

?O(n3) time

T AB CA TT

A AA BT a

B TA BC b e

C CB AC c d

Ask Little Bird:• For first rule• For the split.

Input: T a1a2a3 ..... an

b d a b a e a a d b

T

C A

CFG G Generates I(Parsing)

T AB CA TT

A AA BT a

B TA BC b e

C CB AC c d

Ask left friend:• Instance: C baeaadb• Solution: Left parsing


b a e a a d b

C

T

b d a

A

A

A

B

A

C

C B

A CTA B


T AB CA TT

A AA BT a

B TA BC b e

C CB AC c d

Ask right friend:• Instance: A bda• Solution: Right parsing


A

B T

C A

b d a

T

C

b a e a a d b


T AB CA TT

A AA BT a

B TA BC b e

C CB AC c d

Combine:• Instance: • Bird’s Answer• Left Friend’s Answer• Right Friend’s Answer


A

A

B

A

C

C B

A CTA B

B T

C A

T

b d a b a e a a d b

C A


T’ aiai+1 ..... aj non-terminals T’

& i,j [1,n]

sub-Instances:

Running time = ( # of sub-instances × # bird answers ) = ( # of non-terminals × n2

gives: First rule and split

× # of rules · n )

Done




Will prove:



?O(n3) timeUndecidable

CFG Generates Everything

GIVEN:

Oracle for

<M,I>

BUILD:

Oracle for

{<M,I> | M halts on I} {<G> | CFG G generates every string}

{<M,I> | M halts on I} ≤ {<G> | CFG G generates every string}

No, M(I) does not halt

<G>Grammar G rules mimic the rules of the TM M

on input I

Yes, there is a parsing of everything


GIVEN:

Oracle for

<M,I>

BUILD:

Oracle for



Yes, M(I) does halt


on input I

No, the string corresponding to the computation cant be parsed



10qi10010

CFG Generates EverythingConsider some configuration of a TM

101 1 0 1 0q



I


101 1 0 1 0q

TM accepts by halting in the accept state with the tape empty




101 1 0 1 0q

• Can a CFG generate this string?

Linked because must be the same string

α # αLinked because must be the same string

No




101 1 0 1 0q

• Can a CFG generate every string but this string?

α # β α≠β

Yes




101 1 0 1 0q

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




101 1 0 1 0q

M does not halt on I there is no such a computation string

CFG can generate every string Oracle says yes




101 1 0 1 0q

• A string is not this string if at least one of:• It does not start with #qstartI#

• It does not end with #qaccept#

• Some time step #10q710010#100q60010# is not according to the TM M.


101 1 0 1 0q

{0,1}* #10q710010#100q60010# {0,1}*

• Some time step is not according to the TM M.

This is correct, but we need it to be wrong

• Not according to the TM M if at least one of:• Not (#{0,1}*qi{0,1}*)*#• Transition rule incorrect.• Early unchanged tape not copied correctly• Late unchanged tape not copied correctly


101 1 0 1 0q

{0,1}* #10q710010#100q60010# {0,1}*

• Early unchanged tape not copied correctly

{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’ A# B 1A {qi} A # A• A CA | ε C 0 | 1• B CBC 0A{qi}A#

B A

The rest is similar

GIVEN:

Oracle for

<M,I>

BUILD:

Oracle for



No, M(I) does not halt


on input I

Yes, there is a parsing of everything




Will prove:



?

O(n3) timeUndecidableO(~n) time

CFG G Generates Some String

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?

CFG G Generates Some StringG =• 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 ε.


• Does G2 generate ε?• We need a parsing that gets rid of all non-terminals.• Non-terminal B can be replaced with ε.• Why ever use the rule B AC instead of B ε

G2 = • S ASA | ABA | CA• A AB | B • B BS | ε | AC• C CSA | CAS | BAB

• G2 generates ε iff G3 generates ε.

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

G3 = • S ASA | ABA | CA• A AB | B • B ε • C CSA | CAS | BAB


• Does G4 generate ε?•Why use A A instead of A ε•Lets just plug in A ε


G5 = • S S | ε | C • C CS | CS | ε

G4 = • S ASA | AA | CA• A A | ε • C CSA | CAS | A


• Does G5 generate ε?•Yes using S ε•Hence, G generates some string!

G5 = • S S | ε | C • C CS | CS | ε

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?

CFG G Generates Some StringG =• 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 ε.


• Does G2 generate ε?• The number non-terminals in our string never goes down• G2 does not generate ε.•Hence, G does not generate any strings!

G2 = • S ASA | ABA | CA• A AB | B • B BS | AC• C CSA | CAS | BAB



Will prove:



?

O(n3) timeUndecidableO(~n) timeUndecidable

L(G) = L(G’)

GIVEN:

Oracle for

<G>

BUILD:

Oracle for

{<G> | CFG G generates every string}

{<G,G’> | L(G) = L(G’)}

{<G> | CFG G generates every string} ≤ {<G,G’> | L(G) = L(G’)}

Yes, G generates every string

<G,G’>G’ =• S AS | ε• A 0| 1

Yes, L(G) = L(G’)

L(G) = L(G’)

Context Free Grammars



Will prove:



O(n3) timeUndecidableO(~n) timeUndecidable

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

http://en.wikipedia.org/wiki/File:Game_of_life_beehive.svg

http://en.wikipedia.org/wiki/File:Game_of_life_blinker.gif

http://en.wikipedia.org/wiki/File:Game_of_life_toad.gif

http://en.wikipedia.org/wiki/File:Game_of_life_beacon.gif

http://en.wikipedia.org/wiki/File:Game_of_life_pulsar.gif

http://en.wikipedia.org/wiki/File:Game_of_life_animated_glider.gif

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 multi-variate polynomial • 2x2y8z3 + 7x3y2 - 8x4y2z5 = 0

• Output: Does it have integer values giving zero?

• Undecidable!• Proof not hard. Maybe we will cover it.

The End

Documents

Jeff Edmonds York University COSC 4111 Lecture 4 Different ModelsDifferent ModelsDifferent ModelsDifferent Models ReductionsReductionsReductions Simple