/
Jeff Edmonds Jeff Edmonds

Jeff Edmonds - PowerPoint Presentation

test
test . @test
Follow
415 views
Uploaded On 2016-05-02

Jeff Edmonds - PPT Presentation

York University COSC 4111 Lecture 4 4111 Computability Different Models Reductions Simple Reductions Rices Theorem Acceptable Acceptability Complete Reductions to the Halting Problem The Post Correspondence Prob ID: 302215

oracle halts alg string halts oracle string alg generates cfg input reductions problem halt halting build run comp algorithm undecidability undecidable configuration

Share:

Link:

Embed:

Download Presentation from below link

Download Presentation The PPT/PDF document "Jeff Edmonds" is the property of its rightful owner. Permission is granted to download and print the materials on this web site for personal, non-commercial use only, and to display it on your personal computer provided you do not modify the materials and that you retain all copyright notices contained in the materials. By downloading content from our website, you accept the terms of this agreement.


Presentation Transcript

Slide1

Jeff EdmondsYork University

COSC 4111

Lecture

4

4111 Computability

Different ModelsReductionsSimple ReductionsRice's TheoremAcceptableAcceptability 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 10

th

ProblemSlide2

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

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.

Reductions for UndecidabilitySlide4

Oracle

Alg

Assume have an alg.

Design an alg.

Reductions

But there is likely not a fast algorithm for either!!!Slide5

Reductions

I

harder

I

harder

yes

P

harder

I

harder

no

I

easier

I

easier

yes

P

easier

I

easier

no

Two problems/languages

P

easier

and

P

harder

each with their own definitions of

what a legal input is (

I

easier

vs

I

harder

) and

which are

yes

-inputs and which

no

-inputs.Slide6

Reductions

I

harder

I

harder

yes

P

harder

I

harder

no

I

easier

I

easier

yes

P

easier

I

easier

no

We want machines that decide/accept them.

Alg

harder

P

harder

(I

harder

)

I

harder

P

easier

(I

easier

)

I

easier

Alg

easierSlide7

Reductions

P

easier

≤comp Pharder

I

harder

I

harder

yes

P

harder

I

harder

no

I

easier

I

easier

yes

P

easier

I

easier

no

How do their complexities/difficulties compare?

Computable/Decidable

Exp

Poly

NP

Co-NP

Recognizable

Co-RecognizableSlide8

Reductions

P

easier

≤comp Pharder

I

harder

I

harder

yes

P

harder

I

harder

no

I

easier

I

easier

yes

P

easier

I

easier

no

It is hard to prove problem is

P

harder

hard.

It is easier to prove

P

easier

is easy.

by design an algorithm

Alg

easier

for it.

But you only need to prove

P

easier

is at least as easy as

P

harder

.

Pretend you have an algorithm

Alg

harder

for

P

harder

to use as a subroutine.Slide9

Reductions

P

alg

≤comp Poracle

I

oracle

I

oracle

yes

P

oracle

I

oracle

no

I

alg

I

alg

yes

P

alg

I

alg

no

We often call the algorithm assumed to exist, an

Oracle

.

Given

Alg

oracle

P

oracle

(I

oracle

)

I

oracleSlide10

Reductions

P

alg

≤comp Poracle

I

oracle

I

oracle

yes

P

oracle

I

oracle

no

I

alg

I

alg

yes

P

alg

I

alg

no

We use

Alg

oracle

as an subroutine

in an algorithm

Alg

alg

for solving

P

alg

.

Given

Alg

oracle

P

oracle

(I

oracle

)

I

oracle

Build

Alg

Alg

P

alg

(I

alg

)

I

algSlide11

Reductions

P

alg

≤comp Poracle

I

oracle

I

alg

I

alg

Alg

alg

is given an input

I

alg

.

Given

Alg

oracle

P

oracle

(I

oracle

)

I

oracle

I

oracle

=

InstanceMap

(

I

alg

)

Build

Alg

Alg

P

alg

(I

alg

)

I

alg

InstanceMap

I

oracle

It maps it to input

I

oracle

.

and gives this to

Alg

oracle

. Slide12

Reductions

P

alg

≤comp Poracle

I

oracle

I

alg

I

alg

Alg

oracle

gives the yes/no answer for his input

I

oracle

.

Given

Alg

oracle

P

oracle

(I

oracle

)

I

oracle

I

oracle

=

InstanceMap

(

I

alg

)

Build

Alg

Alg

P

alg

(I

alg

)

I

alg

Return same answer yesyes no no

InstanceMap

I

oracle

yes

P

oracle

I

oracle

no

Alg

alg

returns the same answer. Slide13

Reductions

P

alg

≤comp Poracle

I

oracle

I

alg

To ensure

Alg

alg

works,

I

oracle

=

InstanceMap

(

I

alg

)

must

Given

Alg

oracle

P

oracle

(I

oracle

)

I

oracle

I

oracle

=

InstanceMap

(

I

alg

)

Build

Alg

Alg

P

alg

(I

alg

)

I

alg

Return same answer yesyes no no

InstanceMap

I

oracle

yes

P

oracle

I

oracle

no

I

alg

yes

P

alg

I

alg

no

map yes instances to yes instances and no to no.Slide14

Reductions

P

alg

≤comp Poracle

I

oracle

I

alg

Must prove

Alg

alg

works.

Given

Alg

oracle

P

oracle

(I

oracle

)

I

oracle

I

oracle

=

InstanceMap

(

I

alg

)

Build

Alg

Alg

P

alg

(I

alg

)

I

alg

Return same answer yesyes no no

InstanceMap

I

oracle

yes

P

oracle

I

oracle

no

I

alg

yes

P

alg

I

alg

no

I

alg

is a

yes

input



I

oracle

is a

yes

input



Alg

oracle

says

yes



Alg

alg

says

yesSlide15

Reductions

P

alg

≤comp PoracleSlide16

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

PoracleSlide17

GIVEN:

Network

Flow

Oracle

BUILD:

Matching

Oracle

Matching ≤comp Network Flows

Who loves who

Ann

Fred

Sue

John

Beth

Bob

Mary

Sam

Max matching

A network

s

t

Max Flow

s

t

ReductionsSlide18

Learn that a new problem

is likely hard, from knowing

a known problem is likely hard.

ReductionsHalting

Computable

Exp

PolySlide19

Is there an algorithm for

P

oracle

?Is there an algorithm for

Palg?

?

We give an algorithm for

Palg

using a

supposed algorithm for

P

oracle

as a subroutine.

ReductionsSlide20

If there is an

algorithm for

P

algthen there is an

algorithm for Palg

then there is not fast

algorithm for

Poracle

If there is not an

algorithm for

P

alg

If there is an

algorithm for

P

oracle

If there is not an

algorithm for

P

oracle

?

?

We give an algorithm for

P

alg

using a

supposed algorithm for

P

oracle as a subroutine.?

?

??

??ReductionsSlide21

Notation:

P

alg

≤comp Poracle

Palg is “at least as easy as” Poracle (Modulo polynomial terms.)

P

oracle is “at least as hard as” Palg (Modulo polynomial terms.)

Conclusions:

We give an algorithm for

P

alg

using a

supposed algorithm for

P

oracle

as a subroutine.

ReductionsSlide22

Reductions for Undecidability

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* {<I> | 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}

?Slide23

Reductions for Undecidability

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 outputSlide24

Reductions for Undecidability

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

}

suppressing

any outputSlide25

Reductions for Undecidability

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

GIVEN:

Oracle for

BUILD:

Oracle for Slide26

Reductions for Undecidability

<M,I>

<M

I

>

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

M

I

(I') =

{

Ignore input I'

M & I are built in

Run M(I)

}

Yes or No

GIVEN:

Oracle for

BUILD:

Oracle for Slide27

Reductions for Undecidability

<M,I>

<M

I

>

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

M

I

(I') =

{

Ignore input I'

M & I are built in

Run M(I)

}

Yes or No

GIVEN:

Oracle for

BUILD:

Oracle for Slide28

Reductions for Undecidability

Wait until we do Rice’s Theorem

Wait until we do Rice’s TheoremSlide29

Reductions for Undecidability

<M,I>

<M

I

>

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

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

M(I) halts or not

M

I

(I') =

{

Ignore input I'

M & I are built in

Run M(I)

Yes or No

GIVEN:

Oracle for

BUILD:

Oracle for

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

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

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

suppressing

any output

Halt and accept

} Slide30

Reductions for Undecidability

<M,I>

<M

I

>

{<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(M

I

) = {everything}

Yes , L(M

I

) is regular

GIVEN:

Oracle for

BUILD:

Oracle for

M

I

(I') =

{

Ignore input I'

M & I are built in

Run M(I)

suppressing

any output

Halt and accept

} Slide31

Reductions for Undecidability

<M,I>

<M

I

>

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

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

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

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

M(I) does not halt

L(M

I

) = {nothing}

Yes, L(M

I

) is regular

GIVEN:

Oracle for

BUILD:

Oracle for

M

I

(I') =

{

Ignore input I'

M & I are built in

Run M(I)

Halt and accept }

suppressing

any outputSlide32

Reductions for Undecidability

<M,I>

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

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

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

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

GIVEN:

Oracle for

L(M

I

) =

No, L(M

I

) is not regular

BUILD:

Oracle for

0

n

1

n

M(I) does not halt

M

I

accepts 0

n

1

n

, but “computes” no language

<M

I>MI(I') = {

If I’ has the form 0n1n halt and accept else run M(I) halt and accept } suppressing

any outputSlide33

Reductions for Undecidability

<M,I>

<M

I

>

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

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

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

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

GIVEN:

Oracle for

L(M

I

) =

Yes, L(M

I

) is regular

BUILD:

Oracle for

{everything}

M(I) halts

<M

I

>

M

I

(I') =

{

If I’ has the form 0

n1n halt and accept

else run M(I) halt and accept } suppressing

any outputSlide34

Reductions for Undecidability

<M,I>

<M

I

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

GIVEN:

Oracle for

BUILD:

Oracle for

M

I

(I') = M' = ?

{

Ignore input I'

M & I are built in

Run M(I)

Halt and accept

}

suppressing

any outputSlide35

Reductions for Undecidability

<M

I

,M'>

If M halts on I

M

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

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

{<M,M'> |

I

M(I)=M'(I)}

M'(I') halts and accepts

M

I

(I') = M' = ?

{

Ignore input I'

M & I are built in

Run M(I)

Halt and accept

}

suppressing

any outputSlide36

Reductions for Undecidability

<M

I

,M'>

If M does not halt on I

M

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

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

{<M,M'> |

I

M(I)=M'(I)}

M

I

(I') = M' = ?

{

Ignore input I'

M & I are built in

Run M(I)

Halt and accept

}

suppressing

any output

M'(I') halts and acceptsSlide37

Reductions for Undecidability

<M,I>

<M

I

,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

Yes or No

GIVEN:

Oracle for

BUILD:

Oracle for

M

I

(I') = M' = ?

{

Ignore input I'

M & I are built in

Run M(I)

Halt and accept

}

suppressing

any output

M'(I') halts and acceptsSlide38

Reductions for Undecidability

<M,I>

<I'>

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

{<I> | M

*

halts on I}

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

{<I> | M

*

halts on I}

where M

*

is a special TM

M(I) halts or not

Need to tell oracle

about M and I

I' = <M,I>

M* is the

universal TM

simulates M on I.

Yes or No

GIVEN:

Oracle for

BUILD:

Oracle for Slide39

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

Reductions for Undecidability

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

(Else switch to P)

Assume M

yes

ϵ

P

Let M

empty

= just say no.

L(

M

empty

) = {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.Slide41

Reductions for Undecidability

GIVEN:

Oracle for

<M,I>

BUILD:

Oracle for

<M'>

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

P

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

M(I) halts

M'(I') =

{

Run M(I)

Run

M

yes

(I')

respond as

M

yes

(I') does

}

Yes

P = {<M> | based on what M does,

not on how it does it}

L(M') = L(

M

yes

) Myes ϵ P 

M' ϵ P Slide42

Reductions for Undecidability

GIVEN:

Oracle for

<M,I>

BUILD:

Oracle for

<M'>

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

P

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

M(I) does not halt

M'(I') =

{

Run M(I)

Run

M

yes

(I')

respond as

M

yes

(I') does

}

No

P = {<M> | based on what M does,

not on how it does it}

L(M') = {nothing}

=

L(

Mempty) M

empty ϵ P  M' ϵ P Slide43

Reductions for Undecidability

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

GIVEN:

Oracle for

BUILD:

Oracle for

Other directionSlide44

Reductions for Undecidability

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 print “Hi”

M'(I) =

{

Run M(I)

if “Hi” is printed halt

Loop forever

}

No, does not haltSlide45

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* {<I> | 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 AcceptabilitySlide46

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

BUILD:

Oracle for

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

Reductions for AcceptabilitySlide47

<M,I>

<M,I>

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

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

≤ {<M,I> | M does

not

halt on I}

Yes: Does halt

No: Does halt.

GIVEN:

Oracle for

BUILD:

Oracle for

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

Wait! Is this allowed?

Reductions for AcceptabilitySlide48

P

alg

comp Poracle

Karp Reduction: Yes

 Yes & No  No

Cook Reduction: Design any algorithm for P

alg using a supposed algorithm for Poracle as a subroutine.

Reductions for Acceptability

Wait! Is this allowed?Slide49

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

 Halt and answer “no”

Co-AcceptableHaltingHalting

Reductions for AcceptabilitySlide50

P

alg

comp Poracle

Karp Reduction: Yes

 Yes & No  No

Cook Reduction: Design any algorithm for P

alg using a supposed algorithm for Poracle as a subroutine.

Reductions for Acceptability

We will only consider reductions of this simple form.

Because they preserve

acceptable/co-acceptableSlide51

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”

Co-Acceptable

Halting

Reductions for Acceptability

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

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

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”

Co-Acceptable

Halting

Reductions for Acceptability

Halting

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

{<M,M'> |

I

M(I)=M'(I)}

Halting

Halting ≤Slide53

Yes

instance

Halt and answer “yes”No instance  Run forever or answer “no”

Acceptable

Halting

Acceptability Complete

Def

n

: Problem

P

complete

is

Acceptability Complete

iff

P

complete

Acceptability

P

Acceptability, P ≤comp PcompleteI.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.

PcompleteSlide54

Yes

instance

Halt and answer “yes”No instance  Run forever or answer “no”

Acceptable

Halting

Acceptability Complete

Claim:

Halting

is

Acceptability Complete

.

Halting

Acceptability

P

Acceptability,

There is a TM

M

P

such that We must now prove P ≤comp Halting Slide55

Reductions for Undecidability

I

<M

I

,0>

I

P

M

I

(I’) =

{

Run

M

P

(I)

If halt and accept

halt and accept

else run forever

}

Halts

GIVEN:

Oracle for

BUILD:

Oracle for

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

P

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

Reductions for Undecidability

I

I

P

M

I

(I’) =

{

Run

M

P

(I)

If halt and accept

halt and accept

else run forever }

Runs forever

GIVEN:

Oracle for

BUILD:

Oracle for

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

P

P

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

<M

I

,0>Slide57

Yes

instance

Halt and answer “yes”No instance  Run forever or answer “no”

Acceptable

Halting

Acceptability Complete

Claim:

Halting

is

Acceptability Complete

.

Halting

Acceptability

P

Acceptability,

There is a TM

M

P

such that We proved P ≤comp HaltingSlide58

Acceptable

Halting

Acceptability Complete

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

Acceptable

Halting

Acceptability Complete

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)}Slide60

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

The Post Correspondence Problem

The input is a finite collection of dominoes

A solution is a finite sequence of the dominoes

(with repeats)

b

ca

a

ab

ca

a

abc

c

a

ab

So that the combined string on the top

is the same as that on the bottom

a b c a a a b c

a b c a a a b c

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

b

ca

,

a

ab

,

ca

a

,

abc

c

P =

PCP is undecidableSlide62

GIVEN:

Oracle for

<M,I>

BUILD:

Oracle for

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

{<P> | Dominos P has a solution}

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

{<P> | Dominos P has a solution}

Yes M(I) halts

<P>

Dominos in P mimic

the rules of the TM M

on input I

Yes, there is a solution

The Post Correspondence ProblemSlide63

Encode configuration of the TM as a string

giving the contents of the tape

and the current state inserted where the head is.10qi

10010The Post Correspondence ProblemConsider some configuration of a TM 1

01

1

0

1

0

qSlide64

Encode the halting computation of M on I

as the string of configurations separated by ‘#

’#q

start0110010#1q3010010#10q710010#100q

60010#10 …. #qaccept

#

I

The Post Correspondence Problem

Consider some

configuration

of a TM

1

0

1

1

0

1

0

q

TM accepts by halting in the

accept state with the tape emptySlide65

Encode the halting computation of M on I

as the string of configuration separated by ‘#

’#q

start0110010#1q3010010#10q710010#100q

60010#10 …. #qaccept

#The Post Correspondence Problem

Consider some configuration of a TM 10

1

1

0

1

0

q

M halts on I

iff

there is such a computation string

iff

the dominoes P has a solution

with this string as

the combined string

on the top and on the bottomSlide66

The first domino in P is

The Post Correspondence Problem

Consider some configuration of a TM

101

1

0

1

0

q

#

#

q

start

0110010

#

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

. Slide67

The Post Correspondence Problem

Consider some

configuration of a TM 1

01

1

0

1

0

q

Transition

(

q

i

,1

) = <

qj,c,right>

#

10

q

i

11010

#

Config

:

TM is in state

qi and sees a 1.c01

1010

qj#10qj11010##10qjc1010#

#10cqj1010#Related domino:qi1cqjSlide68

Transition (

qi

,1) = <qj,c,left

>#10qi11010#Config:

TM is in state

q

i and sees a 1.c

0

1

1

0

1

0

q

j

#

10

q

j

11010

#

#

10

q

j

c1010##1qj0c1010#

Related dominoes:0qi1 qj0c

1qi1 qj1c

&Consider some configuration of a TM 1

0

1

10

10qThe Post Correspondence ProblemSlide69

Related dominoes:

Consider some

configuration of a TM 1

01

1

0

1

0

q

Add and removing trailing blanks:

Start a new configuration:

Copy unchanged characters:

#

#

q

accept

##

#

Accepting:

The Post Correspondence Problem

,

0

0

1

1

, &

b

b

#

b

#

b# #

&Slide70

The Post Correspondence Problem

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

consists of the first t TM configurationsand on the bottom the first t+1.

…0# …0#10qi1001b#

Slide71

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

#

0

1

q

i

1

0

0

1

b

#Slide72

The Post Correspondence Problem

With transition (

qi,1) = <q

j,0,right> the only way to match the “qi1” on top is with the dominoThen the remain characters can be copied down.

…0# …

0#10q

i1001b#

0

1

q

i

1

0

0

1

b

#

0

q

j

0

1

0

0

1

b

#Slide73

The Post Correspondence Problem

This maintains the loop invariant that

in the only domino solutionthe combined string so far on the top consists of the first t TM configurationsand on the bottom the first t+1.

…0# …0#10qi

1001b#

0

0

1

1

q

i

1

0

q

j

0

#

10

q

i

1001b

#

0

#10qi1001b#100qj001b#

0

0

0

0

11

bb

##Slide74

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

#

0

1

q

i

1

0

0

1

b

#

0qj

0

1

0

0

1

b

#

…0

#

0

#

10

q

i

1001b#

01q

i

1001

b0qj

0

1

0

0

1

b

#

b

#

This also maintains the loop invariant

0

#

10

q

i

1001b

#

0

#

10

q

i

1001b

#

100

q

j

001bb

#

Slide75

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#

0

1

qi

1

0

0

1

b

#

0

q

j

0

1

0

0

1

b

#

…0

#

0

#

10

q

i

1001b#

01qi1

0

010

qj

0

1

0

0

1

b

#

#

This also maintains the loop invariant

0

#

10

q

i

1001b

#

0

#

10

q

i

1001b

#

100

q

j

001

#

Hence the LI is

always maintained.Slide76

The Post Correspondence Problem

…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 solutionthe combined string so far on the top consists of the first t TM configurationsand on the bottom the first t+1

. Slide77

The Post Correspondence Problem

…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 solutionthe combined string so far on the top consists of the first t TM configurationsand on the bottom the first t+1. Slide78

The Post Correspondence Problem

…0

# …

0#qaccept#

q

accept

###

0

#

q

accept

##

0#q

accept##

And this completes the solution with

the combined string on the top

being the same as that on the bottom.

To this we can add a last domino

to complete the solutionSlide79

The Post Correspondence Problem

0#qaccept##

…0#qaccept##

Of course such a solution is impossible,

if TM M does not halt and accept input I

.Consider some configuration of a TM

1

0

1

1

0

1

0

qSlide80

The first domino in P is

The Post Correspondence Problem

Consider some configuration of a TM

101

1

0

1

0

q

#

#

q

start

0110010

#

I

Lets temporarily assume that the domino

solution must start with this domino.

We now need to consider the problem with this restriction removed.Slide81

The Post Correspondence Problem

Consider these dominoes

##

q

accept##

#

,

0

0

1

1

,

b

b

#

b

#

b

#

#

q

i

1

c

q

j

0

q

i1

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 bottomCan you find a nice easy solution?

0

0Slide82

The Post Correspondence Problem

Insert *s into the dominoes

*##*

*

qaccept*

#*#*

#*

,

*0

0

*

*1

1

*

,

*b

b

*

*

#

b

*

#

*

*

b

*#

#**qi*1c*qj

**0*qi*1

qj0c*

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

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

,,,,

, &

,,,

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

The Post Correspondence Problem

Insert *s into the dominoes

*##*

*

qaccept*

#*#*

#*

,

*0

0

*

*1

1

*

,

*b

b

*

*

#

b

*

#

*

*

b

*#

#**qi*1c*qj

**0*qi*1

qj0c*

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

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

,,,,

, &

,,,

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

GIVEN:

Oracle for

<M,I>

BUILD:

Oracle for

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

{<P> | Dominos P has a solution}

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

{<P> | Dominos P has a solution}

Yes M(I) halts

<P>

Dominos in P mimic

the rules of the TM M

on input I

Yes, there is a solution

The Post Correspondence Problem

DoneSlide85

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 undecidableSlide86

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

the rules of the TM M

on input I

Yes, there is a solution

Tiling ProblemSlide87

Encode configuration of the TM as a string

giving the contents of the tape

and the current state inserted where the head is.10qi

10010Tiling ProblemConsider some configuration of a TM 1

01

1

0

1

0

qSlide88

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.

####################q

start 0110010bbbbbbb##1q3010010bbbbbbbbb##10q710010bbbbbbbbb#

#100q60010bbbbbbbbb##

10 …. bbbbbbbbbbbb##q

acceptbbbbbbbbbbbbb# ###################Tiling ProblemConsider some configuration of a TM

1

0

1

1

0

1

0

q

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

Context Free Grammars

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

{<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(n

3

) timeSlide90

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

a

1a2a3 ..... an

b d a b a e a

a d b T

C A

CFG G Generates I

(Parsing)Slide91

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

Input

: T  a1a2a3 ..... an

b a e aa d b

C T

b d a

A

A

A

BA

C

C

B

A

C

T

A

B

CFG G Generates I

(Parsing)Slide92

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

Input

: T  a1a2a3 ..... an

AB

TC

A

b d a

T

C

b a e a

a d b

CFG G Generates I

(Parsing)Slide93

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

Input

:

T

 a1a2a3 ..... an

AA

BA

CC

B

A

C

TA

B

B

T

C

A

T

b d a

b a e a

a d b

C

A

CFG G Generates I

(Parsing)Slide94

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

CFG G Generates I

(Parsing)Slide95

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

{<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(n

3

) time

Undecidable

CFG Generates EverythingSlide96

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

CFG Generates EverythingSlide97

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}

Yes

, M(I) does halt

<G>

Grammar G rules mimic

the rules of the TM M

on input I

No

, the string

corresponding to the

computation cant be parsed

CFG Generates EverythingSlide98

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 EverythingConsider some configuration of a TM 1

01

1

0

1

0

qSlide99

Encode the halting computation of M on I

as the string of configurations separated by ‘#

’#q

start0110010#1q3010010#10q710010#100q

60010#10 …. #qaccept

#

I

CFG Generates Everything

Consider some

configuration

of a TM

1

0

1

1

0

1

0

q

TM accepts by halting in the

accept state with the tape emptySlide100

Encode the halting computation of M on I

as the string of configurations separated by ‘#

’#q

start0110010#1q3010010#10q710010#100q

60010#10 …. #qaccept

#CFG Generates Everything

Consider some configuration of a TM 10

1

1

0

1

0

q

Can a CFG generate this string?

Linked

because must be

the same string

α

#

α

Linked

because must be

the same string

NoSlide101

Encode the halting computation of M on I

as the string of configurations separated by ‘#

’#q

start0110010#1q3010010#10q710010#100q

60010#10 …. #qaccept

#CFG Generates Everything

Consider some configuration of a TM 10

1

1

0

1

0

q

Can a CFG generate every string but this string?

α

#

β

α

β

YesSlide102

Encode the halting computation of M on I

as the string of configurations separated by ‘#

’#q

start0110010#1q3010010#10q710010#100q

60010#10 …. #qaccept

#CFG Generates Everything

Consider some configuration of a TM 10

1

1

0

1

0

q

M halts on I

there is such a computation string

CFG

c

an generate every string but this string

CFG does not generate every string

Oracle says

noSlide103

Encode the halting computation of M on I

as the string of configurations separated by ‘#

’#q

start0110010#1q3010010#10q710010#100q

60010#10 …. #qaccept

#CFG Generates Everything

Consider some configuration of a TM 10

1

1

0

1

0

q

M does not halt on I

there is no such a computation string

CFG

c

an generate every string

Oracle says

yesSlide104

Encode the halting computation of M on I

as the string of configurations separated by ‘#

’#q

start0110010#1q3010010#10q710010#100q

60010#10 …. #qaccept

#CFG Generates Everything

Consider some configuration of a TM 10

1

1

0

1

0

q

A string is not this string if at least one of:

It does not start with

#

q

start

I

#

It does not end with

#

q

accept

#

Some time step #10q710010#100q60010#

is not according to the TM M.Slide105

CFG Generates Everything

Consider some

configuration of a TM 1

01

1

0

1

0

q

{0,1}

*

#

10

q

710010#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 correctlySlide106

CFG Generates Everything

Consider some

configuration of a TM 1

01

1

0

1

0

q

{0,1}

*

#

10

q

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

#BA

The rest is similarSlide107

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

CFG Generates EverythingSlide108

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

{<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(n

3

) time

Undecidable

O(~n) time

CFG G Generates Some StringSlide109

CFG G Generates Some String

Input: CFG G

Output: Whether generates any string

Algorithm by exampleG =S  abAcdSaaAef | acAadBddAa | cCdAeA aaAbbBb | baBcd B  aaBssSsa | funwow | aAbCcC  ccCcSdAd | efCghAqSr | bBbAbBbDoes this G generate any string? Slide110

CFG G Generates Some String

G =

S

 abAcdSaaAef | acAadBddAa | cCdAeA aaAbbBb | baBcd B  aaBssSsa | funwow | aAbCcC  ccCcSdAd | efCghAqSr | bBbAbBb

We only care if

G generates some string. We don’t care which.

Delete all terminalsG2

= S  ASA | ABA | CAA AB | B

B  BS |

ε

| AC

C  CSA | CAS | BAB

G

generates some string

iff

G2 generates ε.Slide111

CFG G Generates Some String

Does

G

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

ε

G

2 = S  ASA | ABA | CAA AB | B B  BS | ε | ACC  CSA | CAS | BAB

G

2

generates

ε

iff

G

3 generates ε.

G

3

=

S

 ASA | ABA | CA

A AB | B

B 

ε

C  CSA | CAS | BAB Slide112

CFG G Generates Some String

Does

G

3 generate ε?Lets just plug in B  ε

G

3

generates ε iff G4 generates ε.

G

4

=

S

 ASA | AA | CA

A A |

ε

C  CSA | CAS | A

G3 = S

 ASA | ABA | CAA AB | B B 

ε

C  CSA | CAS | BAB Slide113

CFG G Generates Some String

Does

G

4 generate ε?Why use A A instead of A εLets just plug in A  ε

G

4 generates ε iff G5 generates ε.

G

5

=

S

 S |

ε

| C

C  CS | CS | ε

G

4

=

S

 ASA | AA | CA

A A |

ε

C  CSA | CAS | A Slide114

CFG G Generates Some String

Does

G

5 generate ε?Yes using S εHence, G generates some string!

G

5

= S  S | ε | C C  CS | CS | ε Slide115

CFG G Generates Some String

Input: CFG G

Output: Whether generates any string

Algorithm by another exampleG =S  abAcdSaaAef | acAadBddAa | cCdAeA aaAbbBb | baBcd B  aaBssSsa | aAbCcC  ccCcSdAd | efCghAqSr | bBbAbBbDoes this G generate any string? Slide116

CFG G Generates Some String

G =

S

 abAcdSaaAef | acAadBddAa | cCdAeA aaAbbBb | baBcd B  aaBssSsa | aAbCcC  ccCcSdAd | efCghAqSr | bBbAbBb

We only care if

G generates some string. We don’t care which.

Delete all terminalsG2

= S  ASA | ABA | CAA AB | B

B  BS

| AC

C  CSA | CAS | BAB

G

generates some string

iff

G2 generates ε.Slide117

CFG G Generates Some String

Does

G

2 generate ε?The number non-terminals in our string never goes downG2 does not generate ε.Hence, G does not generate any strings

!

G

2 = S  ASA | ABA | CAA AB | B B  BS | ACC  CSA | CAS | BAB Slide118

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

{<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(n

3

) time

Undecidable

O(~n) time

Undecidable

L(G) = L(G’)Slide119

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’)Slide120

Context Free Grammars

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

{<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(n

3

) time

Undecidable

O(~n) time

UndecidableSlide121

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}  diesevery dead cell# live neighbours = 3

 comes aliveSlide122

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}  diesevery 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.Slide123

Hilbert’s 10

th

Problem

Input: a multi-variate polynomial

2x2y8z3 + 7x3

y2 - 8x4y

2z5 = 0Output: Does it have integer values giving zero?

Undecidable!

Proof not hard. Maybe we will cover it.Slide124

The End