Unit 5 Toc

UNIT-5
UNDECIDABILITY
UNDECIDABILITY
There are two types of TMs (based on halting):

1. Halting TM : (Accepts Recursive languages) : TMs that always
halt, no matter accepting or or non-accepting (called as
decidable problems)
2. TM : (Accepts Recursively enumerable): TMs that are
guaranteed to halt only on acceptance. If non-accepting, it may
or may not halt (i.e., could loop forever). (Either decidable or
partially decidable).
UNDECIDABILITY
Recursive Language
A language ‘L’ is said to be recursive if there exists a Turing machine which

will accept all the strings in ‘L’ and reject all the string not in ‘L’. The turing
machine will halt every time and give an answer(accepted or rejected) for each
and every string input. A language ‘L’ is decidable if it is a recursive language.
All decidable languages are recursive languages and vice versa.
UNDECIDABILITY
Decidable Problem
● If there is a Turing machine that decides the problem, called as Decidable problem.
● A decision problem that can be solved by an algorithm that halts on all inputs in a
finite number of steps.
● A problem is decidable, if there is an algorithm that can answer either yes or no.
● A language for which membership can be decided by an algorithm that halts on all
inputs in a finite number of steps.
● Decidable problem is also called as totally decidable problem, algorithmically
solvable, recursively solvable.
UNDECIDABILITY
Undecidable Problem (Semi-decidable or Totally not decidable)
● A problem that cannot be solved for all cases by any algorithm whatsoever.
● Equivalent Language cannot be recognized by a Turing machine that halts for all inputs.
UNDECIDABILITY
The following problems are undecidable problems:
● Halting Problem: A halting problem is undecidable problem. There is no general method or
algorithm which can solve the halting problem for all possible inputs.
● Emptyness Problem: Whether a given TM accepts Empty?
● Finiteness Problem: Whether a given TM accepts Finite?
● Equivalence Problem: Whether Given two TM’s produce same language?. Is L(TM1) =
L(TM2) ?
● Is L(TM1) ⊆ L(TM2) ? (Subset Problem)
● Is L(TM1) Ո L(TM2) = CFL?
● Is L(TM1) = Σ* ? (Totality Problem)
● Is the complement of L(G1) context-free ?
NON RECURSIVELY ENUMERABLE
Our long range goal is to prove undecidable the language consisting of pairs (M,w) such
that:
1. M is a Turing machine (suitably coded, in binary) with input alphabet {0,1}

2. w is a string of 0’s and 1’s, and
3. M accepts input w
Enumerating the Binary Strings

● Need to assign integers to all the binary
strings so that each string corresponds to
one integer.
● That is, is the ∊is the first string, 0 is the
second, 1 the third, 00 the fourth, and 01
the fifth and so on
Codes for Turing Machines

To represent a TM M = (
Q, {0,1},Г,δ,q1,B,F) as
a binary string
Let the TM in question be
M = ({q1,q2,q3},{0,1},{0,1,B}, δ,q1,B,{q2})
where consists of the rules
δ(q1,1)=(q3,0,R)
δ(q3,0)=(q3,1,R)
δ(q3,1)=(q2,0,R)
δ(q3,B)=(q31,L)
M = ({q1,q2,q3},{0,1},{0,1,B}, δ,q1,B,{q2})
M = ({q1,q2,q3},{0,1},{0,1,B}, δ,q1,B,{q2})
q1 0
M = ({q1,q2,q3},{0,1},{0,1,B}, δ,q1,B,{q2})
q1 0, q2 00
M = ({q1,q2,q3},{0,1},{0,1,B}, δ,q1,B,{q2})
q1 0, q2 00 ,q3 000
M = ({q1,q2,q3},{0,1},{0,1,B}, δ,q1,B,{q2})
q1 0, q2 00 ,q3 000
M = ({q1,q2,q3},{0,1},{0,1,B}, δ,q1,B,{q2})
q1 0, q2 00 ,q3 000
0 0
M = ({q1,q2,q3},{0,1},{0,1,B}, δ,q1,B,{q2})
q1 0, q2 00 ,q3 000
0 0, 1 00
M = ({q1,q2,q3},{0,1},{0,1,B}, δ,q1,B,{q2})
q1 0, q2 00 ,q3 000
0 0, 1 00, B 000
M = ({q1,q2,q3},{0,1},{0,1,B}, δ,q1,B,{q2})
q1 0, q2 00 ,q3 000
0 0, 1 00, B 000
L 0, R 00

M = ({q1,q2,q3},{0,1},{0,1,B}, δ,q1,B,{q2})
δ(q1,1)=(q3,0,R)
M = ({q1,q2,q3},{0,1},{0,1,B}, δ,q1,B,{q2})
δ(q1,1)=(q3,0,R) 0100100010100
M = ({q1,q2,q3},{0,1},{0,1,B}, δ,q1,B,{q2})
δ(q1,1)=(q3,0,R) 0100100010100
δ(q3,0)=(q3,1,R)
M = ({q1,q2,q3},{0,1},{0,1,B}, δ,q1,B,{q2})
δ(q1,1)=(q3,0,R) 0100100010100
δ(q3,0)=(q3,1,R) 000101000100100
M = ({q1,q2,q3},{0,1},{0,1,B}, δ,q1,B,{q2})
δ(q1,1)=(q3,0,R) 0100100010100
δ(q3,0)=(q3,1,R) 000101000100100
δ(q3,1)=(q2,0,R)
M = ({q1,q2,q3},{0,1},{0,1,B}, δ,q1,B,{q2})
δ(q1,1)=(q3,0,R) 0100100010100
δ(q3,0)=(q3,1,R) 000101000100100
δ(q3,1)=(q2,0,R) 00010010010100
M = ({q1,q2,q3},{0,1},{0,1,B}, δ,q1,B,{q2})
δ(q1,1)=(q3,0,R) 0100100010100
δ(q3,0)=(q3,1,R) 000101000100100
δ(q3,1)=(q2,0,R) 00010010010100
δ(q3,B)=(q31,L)
M = ({q1,q2,q3},{0,1},{0,1,B}, δ,q1,B,{q2})
δ(q1,1)=(q3,0,R) 0100100010100
δ(q3,0)=(q3,1,R) 000101000100100
δ(q3,1)=(q2,0,R) 00010010010100
δ(q3,B)=(q31,L) 0001000100010010

To represent a TM M = ( Q,
{0,1},Г,δ,q1,B,F) as a binary string
First assign integers to the states,
tape symbols, and directions L and R
To represent a TM M = ( Q, {0,1},Г,δ,q1,B,F) as a binary
string First assign integers to the states, tape symbols, and
directions L and R
● Assume the states are q1,q2…,qr for some r. The start
state will always be q1 and q2will be the only accepting

state.
To represent a TM M = ( Q, {0,1},Г,δ,q1,B,F) as a binary string First
assign integers to the states, tape symbols, and directions L and R
● Assume the states are q1,q2…,qr for some r. The start state will
always be q1 and q2will be the only accepting state.
● Assume the tape symbols are X1,X2,...Xs for some s. X1 always
will be the symbol 0, X2 will be 1, and X3 will be B, the blank

To represent a TM M = ( Q, {0,1},Г,δ,q1,B,F) as a binary string First
assign integers to the states, tape symbols, and directions L and R
● Assume the states are q1,q2…,qr for some r. The start state will always
be q1 and q2will be the only accepting state.
● Assume the tape symbols are X1,X2,...Xs for some s. X1 always will be
the symbol 0, X2 will be 1, and X3 will be B, the blank.
● Assume the direction L as D1 and direction R as D2.

To represent a TM M = ( Q, {0,1},Г,δ,q1,B,F) as a binary string
Once we have established an integer to represent each state,
symbol, and direction. we can encode the transition function
Suppose one transition rule is
δ(qi,Xj)= (qk,Xl,Dm) ,for some integers i, j, k, l, and m
We shall codevthis rule by the string 0i10j10k10l10m

A code for the entire TM M consists of all the codes for
the transitions, in some order, separated by pairs of 1’s
C111C211… Cn-111Cn
where each of the Cs is the code for one transition of

M
Let the TM in question be M = ({q1,q2,q3},{0,1},{0,1,B}, δ, q1, B, {q2})
δ(q1,1)=(q3,0,R) 0100100010100
δ(q3,0)=(q3,1,R) 000101000100100
δ(q3,1)=(q2,0,R) 00010010010100
δ(q3,B)=(q31,L) 0001000100010010
0100010001010011000101000100100110001001001010011000100010010
Need to code pairs consisting of a TM and a string, ( M,w) .
For this pair we use the code for M followed by 111 followed by w
Need to code pairs consisting of a TM and a string, ( M,w) .
For this pair we use the code for M followed by 111 followed by w
0100010001010011000101000100100110001001001010011000100010010111101
1
The Diagonalization Language
There is now a concrete notion of M i, the ith Turing
machine that TM M whose code is w i the ith binary string
Many integers do not correspond to any TM at al l


Many integers do not correspond to any TM at all.
For instance, 11001 does not begin with 0.
0010111010010100 is not valid
If wi is not a valid TM code, we shall take Mi to be the TM with one state and no transitions.
That is, for these values of i, Mi is a Turing machine that immediately halts on any input.
Thus, L(Mi) is Ø, if wi fails to be a valid TM code

The language Ld the diagonalization language, is the set of
strings wi such that wi is not in L(Mi).


The diagonal values tell whether Mi accepts wi .
Proof That Ld Is Not Recursively Enumerable
Theorem : Ld is not a recursively enumerable language
That is, there is no Turing machine that accepts Ld.

Theorem : Ld is not a recursively enumerable language That is, there is no Turing machine that accepts L d.
PROOF:
● Suppose Ld were L(M) for some TM M.
● Since Ld is a language over alphabet {0,1}, would be in the list of Turing machines we have
constructed, since it includes all TMs with input alphabet {0,1}.

Thus, there is at least one code for M, say i that is, M= Mi
Theorem : Ld is not a recursively enumerable language That is, there is no Turing machine that accepts Ld.
PROOF:
● If wi is in Ld, then Mi accepts wi. But then, by definition of Ld, wi is not in Ld, because Ld contains only
those wj such that Mj does not accept wj.
● Similarly, if wi is not in Ld, then Mi does not accept wi. Thus, by definition of Ld, wi is in Ld.
Since wi can neither be in Ld nor fail to be in Ld. we conclude that there is a contradiction of our assumption
that M exists. That is, Ld is not a recursively enumerable language,

AN UNDECIDABLE PROBLEM THAT IS RE
1. Recursive language
2. Recursive Enumerable
language
3. Universal language
Recursive language
A language L recursive if L = L(M) for some
Turing machine M such that:
1. If w is in L, then M accepts (and therefore
halts)
2. If w is not in L, then M eventually halts,
although it never enters an accepting state
Recursive language
A language L recursive if L = L(M) for some
Turing machine M such that:
1. If w is in L, then M accepts (and therefore
halts)
2. If w is not in L, then M eventually halts,
although it never enters an accepting state
Recursively enumerable language
TM : TMs that are guaranteed to halt are

guaranteed to halt only on acceptance. If non-
accepting, it may or may not halt (i.e., could loop
forever). (Either decidable or partially decidable).
The relationship among three classes of

languages
● The recursive languages
● The languages that are recursively
enumerable but not recursive
● The non recursively enumerable
(nonRE) languages
Theorem: If L is a recursive language, so is L’ ( )
Theorem: If L is a recursive language, so is L’
PROOF:
● Let L= L(M) for some TM M that always halts.
PROOF:
● We construct a TM M’ such that L’= L(M’) by the construction as
shown in figure.
PROOF:
● We construct a TM M’ such that L’= L(M’) by the construction as
shown in figure.
T heorem: If L is a recursive language, so is L’

PROOF:
1. The accepting states of M are made nonaccepting

states of M’ with no transitions, ie. in these states M
will halt without accepting
T heorem: If L is a recursive language, so is L’

PROOF:
2. M has a new accepting state r, there are no

transitions from r.

PROOF:
3. For each combination of a nonaccepting state of M

and a tape symbol of M such that M has no transition, add
a transition to the accepting state r
TM M = ( Q, ∑,Г,δ,q1,B,F ) then
M’=(Q, ∑,Г,δ’,q1,B,Q-F) that is
TM M = ( Q, ∑,Г,δ,q1,B,F ) then M’=(Q, ∑,Г,δ’,q1,B,Q-F)
Since M is guaranteed to halt, we know that M’ is also guaranteed to
halt
Moreover, M’ accepts exactly those strings that M does not accept Thus
M,
accepts L’.
Theorem: If both a language L and its complement are RE,

then L is recursive
Theorem: If both a language L and its complement are RE, then L is
recursive.
PROOF
● Let L=L(M1) and L’= L(M2).
recursive.
PROOF
● Both M1 and M2, are simulated in parallel by a TM M.
heorem: If both a language L and its complement are RE, then
T
L is recursive.
PROOF
● Both M1 and M2, are simulated in parallel by a TM M.
● One tape of M simulates the tape of M1 while the other
tape of M simulates the tape of M2.

recursive.
PROOF
recursive.
PROOF:
● If input w to M is in L, then M1 will eventually accept.
recursive.
PROOF:
● If input w to M is in L, then M1 will eventually accept.If so, M
accepts and halts
recursive.
PROOF:
● If input w to M is in L, then M1 will eventually accept.If so, M
accepts and halts
recursive.
PROOF:
● If w is not in L, then it is in L, so M2 will eventually accept. When
M2 accepts, M halts without accepting
recursive.
PROOF: Thus, on all inputs, M halts, and L(M) is exactly L. Since M
always halts, and L(M)= L, we conclude that L is recursive
● Both L and L’ are

recursive ie, both are in
the inner ring.
● Neither L nor L’ is RE
ie, both are in the outer
ring
● L is RE but not
recursive, and L’ is not
RE ie, one is in the
middle ring and the
other is in the outer ring
● L’ is RE but not
recursive, and L is not
RE; ie, the same as
above) but with L and L’
swapped.
The universal language
The Universal Language
A single TM can be used as a stored program computer, taking its program as
well as its data from one or more tapes on which input is placed
● We define Lu, the universal language, to be the set of binary strings that
encode, in the notation of a pair (M,w), where M is a TM with the binary input
alphabet, and w is a string in (0+1)*, such that w is in LM.
● That is, Lu is the set of strings representing a TM and an input accepted by
that TM.
● We shall show that there is a TM U, often called the universal Turing machine,
such that Lu =L(U)
It is easiest to describe U as a multitape Turing machine.
In the case of U, the transitions of M are stored initially on the first tape, along
with the string w.
A second tape will be used to hold the simulated tape of M, using the same
format as for the code of M.That is, tape symbol Xi of M will be represented by 0i,
and tape symbols will be separated by single 1’s.
The third tape of U holds the state of M, with state qi represented by i’s.
The operation of U can be summarized as follows
1. Examine the input to make sure that the code for M is a legitimate code for
some TM. If not, U halts without accepting. Since invalid codes are assumed
to represent the TM with no moves, and such a TM accepts no inputs, this
action is correct.
2. Initialize the second tape to contain the input w, in its encoded form. That is, for
each 0 of w, place 10 on the second tape, and for each 1 of w, place 100 there.
Note that the blanks on the simulated tape of M, which are represented by 1000, will
not actually appear on that tape; all cells beyond those used for w will hold the blank of
U.
However, U knows that, should it look for a simulated symbol of M and find its own
blank, it must replace that blank by the sequence 1000 to simulate the blank of M
3. Place 0, the start state of M, on the third tape, and move the head of U’s
second tape to the first simulated cell
4. To simulate a move of M, U searches on its first tape for a transition 0 i0j0k0l0m,

such that 0i is the state on tape 3, and 0j is the tape symbol of M that begins at the
position on tape scanned by U .This transition is the one M would next make
a) Change the contents of tape 3 to 0k; that is, simulate the state change of M
To do so, U first changes all the 0’s on tape 3 to blanks, and then copies 0 k
from tape 1 to tape 3.
b) Replace 0j on tape by 0l; that is, change the tape symbol of M. If more or less
space is needed (i.e., i ≠ l) , use the scratch tape and the shifting over
technique to manage the spacing.
c) Move the head on tape 2 to the position of the next 1 to the left or right,
respectively, depending on whether m =1 (move left) or m = 2 (move right).
Thus, U simulates the move of M to the left or to the right
4. If M has no transition that matches the simulated state and tape symbol, then in
(4), no transition will be found Thus, M halts in the simulated configuration and U
must do likewise.
5. If M enters its accepting state, then U accepts

Undecidability of the Universal Language
Theorem: Lu is RE but not recursive

● Suppose Lu were recursive.

● Then by Theorem, the complement of Lu, would also be recursive.
● However, if we have a TM M to accept Lu, then we can construct a TM to
accept Ld (by a method explained below)
● Since we already know that Ld is not RE, we have a contradiction of our
assumption that Lu is recursive.
Suppose L(M)=Lu’.
we can modify TM M into a TM M’ that accepts Ld as follows
1. Given string w on its input, M’ changes the input to w111w
2. M’ simulates M on the new input. Since M accepts Lu, it will accept if and only
if Mi does not accept wi ; iE., wi is in Ld

Suppose L(M)=Lu’.
we can modify TM M into a TM M’ that accepts Ld as follows
1. Given string w on its input, M’ changes the input to w111w
2. M’ simulates M on the new input. Since M accepts Lu, it will accept if and only
if Mi does not accept wi ; iE., wi is in Ld
Thus, M’ accepts w if and only if w is in Ld.
Ld is not a recursively enumerable language That is, there is no Turing machine that
accepts Ld. we conclude that Lu is not recursive
Undecidable Problems About Turing Machines
Reductions
In general, if we have an algorithm to convert instances of a problem P 1 to

instances of a problem P2, that have the same answer, then we say that P1
reduces to P2 .We can use this proof to show that P2, is at least as hard as P1.
Reductions
In general, if we have an algorithm to convert instances of a problem P 1 to

instances of a problem P2, that have the same answer, then we say that P1
reduces to P2 .We can use this proof to show that P2, is at least as hard as P1.
Reductions
Theorem:
If there is a reduction from P1 to P2, then:
a) If P1 is undecidable then so is P2.

b) If P1 is non-RE, then so is P2.
Turing Machines That Accept the Empty Language
If L(Mi) = Ø, that is, Mi does not accept any input, then w is in Le.
Thus, Le is the language consisting of all those encoded TM ‘s whose language is

empty.
On the other hand, if L(Mi) is not the empty language, then w is in Lne.
Thus, Lne is the language of all codes for Turing machines that accept at least one
input string
we may define the two languages just mentioned as
● Le = { M | L(M) = Ø}
● Lne = { M | L(M) ≠ Ø}
Notice that Le and Lne are both languages over the binary alphabet {0,1}.
Theorem : Lne is recursively enumerable
PROOF:
We have only to exhibit a TM that accepts L ne.
The operation of M is as follows
1. M takes as input a TM code Mi.
2. Using its nondeterministic capability, M guesses an input w that M i might
accept.
3. M tests whether Mi accepts w.
4. If Mi accepts w, then M accepts its own input, which is M i
Theorem : Lne is recursively enumerable

Theorem : Lne is not recursive

Theorem : Le is not RE
A property is trivial if it is either empty (i.e., satisfied by no language at all), or is all

RE languages.Otherwise, it is nontrivial
Rice’s Theorem and Properties of the RE Languages
Theorem: (Rice’s Theorem) Every nontrivial property of the RE languages is

undecidable
Rice’s Theorem and Properties of the RE Languages
For instance, the following are undecidable
1. Whether the language accepted by a TM is empty.

2. Whether the language accepted by a TM is finite.
3. Whether the language accepted by a TM is a regular language.
4. Whether the language accepted by a TM is a context free language.
Post’s Correspondence Problem
We shall prove PCP undecidable by reducing Lu to PCP
Definition of Post’s Correspondence Problem
An instance of Post’s Correspondence Problem (PCP) consists of two lists of
strings over some alphabetΣ. the two lists must be of equal length. We generally
refer to the A and B lists,and write A=w1,w2,...,wk and B=x1,x2,...xk,
for some integer k. For each i, the pair (wi,xi) is said to be a corresponding
pair
Give an instance of PCP, tell whether this instance has a solution.
For instance, let m=4, i1=2,i2=1,i3=1 and i4=3
That is w2w1w1w3=x2x1x1x3
101111110
101111110
Give an instance of PCP, tell whether this instance has a solution.
The Modified PCP
It is easier to reduce Lu to PCP , if we first introduce an intermediate version of

PCP, which we call the Modified Posts Correspondence Problem, or MPCP.
The Modified PCP
In the modified PCP, there is the additional requirement on a solution that the first
pair on the A and B lists must be the first pair in the solution.
The Modified PCP
In the modified PCP, there is the additional requirement on a solution that the first
pair on the A and B lists must be the first pair in the solution. More formally, an
instance of MPCP with lists A=w1,w2,...,wk and B=x1,x2,...xk, and a solution is a list
of 0 0r more integers i1,i2,..., im such that
w1wi1wi2...,wim = x1xi1xi2...,xim
The Modified PCP
We are given an instance of MPCP with lists A=w1,w2,...,wk and B=x1,x2,...xk,
for some integer k.
The Modified PCP
for some integer k.
We assume * and $ are symbols not present in the alphabet Σ of this MPCP
instance .
The Modified PCP
for some integer k.
We assume * and $ are symbols not present in the alphabet Σ of this MPCP
instance .
We construct a PCP instance C=y0,y1,...,yk+1 and D=z0,z1,...zk+1 , as follows:
The Modified PCP
1. For i = 1,2,...,k, let yi be wi with a * after each symbol of wi ,and let zi be xi with
a * before each symbol of xi.
The Modified PCP
2. y=*y1, and z0=z1.
The Modified PCP
2. y=*y1, and z0=z1.
3. yk+1= $ and zk+1=$
The Modified PCP
2. y=*y1, and z0=z1.
3. yk+1= $ and zk+1=$
The Modified PCP
2. y=*y1, and z0=z1.
3. yk+1= $ and zk+1=$
Theorem: MPCP reduces to PCP
Reducing Lu to MPCP
Given a pair (M,w), we construct an instance (A,B) of MPCP such that TM M
accepts input w if and only if (A,B) has a solution
Reducing Lu to MPCP
Let M=(Q,Σ,Γ,δ,q0,B F) be a TM and let w in Σ* be an input string.
We construct an instance of MPCP as follows
Reducing Lu to MPCP
1. The first pair is
List A List B
# #q0w#
Reducing Lu to MPCP
List A List B
# #q0w#
2. Tape symbols and the separator # can be appended to both lists. The pairs
List A List B
X X for
each X in Γ
# #'
Reducing Lu to MPCP
List A List B
# #q0w#
List A List B
X X for each X
in Γ
# #'
3. To simulate a move of M, we have certain pairs that reflect those moves. For all q in Q-F(ie, q is a
nonaccepting state), p in Q, and X, Y and Z in Γ we have:
List A List B
qX Yp if δ(q,X)=(p,Y,R)
ZqX pZY if δ(q,X)=(p,Y,L); Z is
any tape symbol
q# Yp# if δ(q,B)=(p,Y,R)
Zq# pZY# if δ(q,B)=(p,Y,L); Z is any
tape symbol
Reducing Lu to MPCP
4. if q is an accepting state, then for all tape symbols X and Y, there are pairs:
List A List B
XqY q
Xq q
qY q
5. Finally, once the accepting state has consumed all tape symbols
List A List B
q## #
Reducing Lu to MPCP
Let us convert TM
and input string w =01 to an instance of MPCP.

Reducing Lu to MPCP
List A List B
# #q0w#
Reducing Lu to MPCP
List A List B
# #q0w#
We must start with the first pair, (start state q 1 and input 01) as required in any solution to MPCP
A:#
B:#'q101#'
Reducing Lu to MPCP
List A List B
X X for
each X in Γ
# #'
Reducing Lu to MPCP
List A List B
X X for
each X in Γ
# #'
Reducing Lu to MPCP
3.To simulate a move of M, we have certain pairs that reflect those moves. For all q in Q-F(ie, q is a nonaccepting state), p
in Q, and X, Y and Z in Γ we have:
List A List B
qX Yp if
δ(q,X)=(p,Y,R)
any tape symbol
q# Yp# if
δ(q,B)=(p,Y,R)
tape symbol
Reducing Lu to MPCP
3.To simulate a move of M, we have certain pairs that reflect those moves. For all q in Q-F(ie, q is a nonaccepting state), p
in Q, and X, Y and Z in Γ we have:
List A List B
qX Yp if
δ(q,X)=(p,Y,R)
any tape symbol
q# Yp# if
δ(q,B)=(p,Y,R)
tape symbol
Reducing Lu to MPCP
List A List B
XqY q
Xq q
qY q
Reducing Lu to MPCP
List A List B
XqY q
Xq q
qY q
Reducing Lu to MPCP
List A List B
q## #
Reducing Lu to MPCP
List A List B
q## #
The Classes P and NP
Problems Solvable in Polynomial Time
A Turing machine M is said to be of time complexity T(n) [or to have running time T(n)], if
wheneverM is given an input w of length n, M halts after making at most T(n) moves,
regardless of whether or not M accepts.
An Example Kruskal’ Algorithm

Problems Solvable in Polynomial Time (An Example Kruskal’ Algorithm)
A minimum weight spanning tree has the least possible total edge weight of all spanning
trees
There is a well-known greedy algorithm, called Kruskal’s Algorithm, for finding a MWST
roblems Solvable in Polynomial Time (An Example Kruskal’ Algorithm)
P
There is a well-known greedy algorithm, called Kruskal’s Algorithm,

for finding a MWST
It is possible to implement this algorithm using a computer, not a

Turing machine on a graph with m nodes and e edges in time O(m+ e
log e)
Problems Solvable in Polynomial Time (An Example Kruskal’
Algorithm)There is a well-known greedy algorithm, called
Kruskal’s Algorithm, for finding a MWST
It is possible to implement this algorithm using a computer, not a

Turing machine on a graph with m nodes and e edges in time
O(m+ e log e)
Algorithm)
When we translate the above ideas to Turing machines, we face
several issues,
● When we deal with Turing machines, we may only think of
problems as languages,and the only output is yes or no, ie,
accept or reject. For instance, the MWST tree problem could
be couched as “given this graph G and limit W, does G have a
spanning tree of weight W or less?”
Algorithm)
Let us consider a possible code for the graphs and weight limits
that could be the input to the MWST problem. The code has five
symbols, 0,1,the left and right parentheses, and the comma
Algorithm)
100
Algorithm)
100,101000
Algorithm)
100,101000(1,10,1111)
Algorithm)
100,101000(1,10,1111)(1,11,1010)(10,11,1100)
(10,100,10100)(11,100,10010)
Algorithm)
1. One tape can be used to store the nodes and their current
component numbers The length of this table is O(n).
2. A tape can be used,as we scan the edges on the input tape, to
hold the currently least edge weight found, among those edges
that have not been marked “used”. Scanning for the lowest
weight, unmarked edge takes O(n) time.
Algorithm)
3. When an edge is selected in a round, This task takes O(n) time.
4. A tape can be used to hold the two components, i and j􀀀 being
merged when an edge is found to connect two previously
unconnected components. This scan also takes O(n) time
An NP Example The Traveling Salesman Problem

Unit 5 Toc

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Unit 5 Toc

Uploaded by

Copyright:

Available Formats

UNIT-5

There are two types of TMs (based on halting):

A language ‘L’ is said to be recursive if there exists a Turing machine which

1. M is a Turing machine (suitably coded, in binary) with input alphabet {0,1}

Enumerating the Binary Strings

Codes for Turing Machines

Codes for Turing Machines

Codes for Turing Machines

● Assume the states are q1,q2…,qr for some r. The start

state will always be q1 and q2will be the only accepting

always be q1 and q2will be the only accepting state.

● Assume the tape symbols are X1,X2,...Xs for some s. X1 always

will be the symbol 0, X2 will be 1, and X3 will be B, the blank

be q1 and q2will be the only accepting state.

the symbol 0, X2 will be 1, and X3 will be B, the blank.

● Assume the direction L as D1 and direction R as D2.

δ(qi,Xj)= (qk,Xl,Dm) ,for some integers i, j, k, l, and m

We shall codevthis rule by the string 0i10j10k10l10m

where each of the Cs is the code for one transition of

Many integers do not correspond to any TM at al l

The Diagonalization Language

Thus, L(Mi) is Ø, if wi fails to be a valid TM code

The language Ld the diagonalization language, is the set of

strings wi such that wi is not in L(Mi).

The Diagonalization Language

Proof That Ld Is Not Recursively Enumerable

Theorem : Ld is not a recursively enumerable language

That is, there is no Turing machine that accepts Ld.

constructed, since it includes all TMs with input alphabet {0,1}.

those wj such that Mj does not accept wj.

that M exists. That is, Ld is not a recursively enumerable language,

Recursively enumerable language

TM : TMs that are guaranteed to halt are

The relationship among three classes of

T heorem: If L is a recursive language, so is L’

1. The accepting states of M are made nonaccepting

T heorem: If L is a recursive language, so is L’

2. M has a new accepting state r, there are no

Theorem: If L is a recursive language, so is L’

3. For each combination of a nonaccepting state of M

Theorem: If both a language L and its complement are RE,

● Let L=L(M1) and L’= L(M2).

● Both M1 and M2, are simulated in parallel by a TM M.

● One tape of M simulates the tape of M1 while the other

tape of M simulates the tape of M2.

● Both L and L’ are

4. To simulate a move of M, U searches on its first tape for a transition 0 i0j0k0l0m,

5. If M enters its accepting state, then U accepts

Theorem: Lu is RE but not recursive

Theorem: Lu is RE but not recursive

● Suppose Lu were recursive.

Theorem: Lu is RE but not recursive

In general, if we have an algorithm to convert instances of a problem P 1 to

In general, if we have an algorithm to convert instances of a problem P 1 to

a) If P1 is undecidable then so is P2.

Thus, Le is the language consisting of all those encoded TM ‘s whose language is

we may define the two languages just mentioned as

Theorem : Lne is recursively enumerable

Theorem : Lne is not recursive

A property is trivial if it is either empty (i.e., satisfied by no language at all), or is all

Theorem: (Rice’s Theorem) Every nontrivial property of the RE languages is

For instance, the following are undecidable

1. Whether the language accepted by a TM is empty.