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