15-453

FORMAL LANGUAGES,
AUTOMATA AND
COMPUTABILITY
 ATM = { (M,w) | M is a TM that accepts string w }
HALTTM = { (M,w) | M is a TM that halts on string w }

ETM = { M | M is a TM and L(M) =  }

REGTM = { M | M is a TM and L(M) is regular}

EQTM = {( M, N) | M, N are TMs and L(M) =L(N)}

ALLPDA = { P | P is a PDA and L(P) = Σ* }

ALL UNDECIDABLE
Use Reductions to Prove
Which are SEMI-DECIDABLE?
Let f : Σ*  Σ* be a computable function
such that w  A  f(w)  B

Σ* A B Σ*
f

Say: A is mapping reducible to B;

Write: A m B Also,  A   B, why?
Theorem: If A m B and B is (semi) decidable,
then A is (semi) decidable

Proof: Let M decide B and let f be a

reduction from A to B

We build a machine N that decides A as follows:

On input w:
1. Compute f(w)
2. Run M on f(w)
 ATM = { (M,w) | M is a TM that accepts string w }
HALTTM = { (M,w) | M is a TM that halts on string w }

CLAIM: ATM m HALTTM

CONSTRUCT f : Σ*  Σ*

f: (M,w)  (M’, w) where M’( w) = M(w) if M(w) accepts

Loops otherwise

So, (M, w ) ATM  (M’, w)  HALTTM

So HALTTM is NOT DECIDABLE, but it is SEMI-
DECIDABLE (Why?)
 ATM = { (M,w) | M is a TM that accepts string w }
ETM = { M | M is a TM and L(M) =  }

CLAIM: ATM m  ETM  ATM m ETM

CONSTRUCT f : Σ*  Σ*
f: (M,w)  Mw where Mw (s) = M(w) if s = w
Loops otherwise
So, M(w) accepts  L (Mw)  

So, (M, w ) ATM  Mw   ETM

So  ETM is NOT DECIDABLE, but it is SEMI-

DECIDABLE (why?) Is ETM SEMI-DECIDABLE?
 ATM = { (M,w) | M is a TM that accepts string w }
REGTM = { M | M is a TM and L(M) is regular}

CLAIM: ATM m REGTM So REGTM is UNDECIDABLE

CONSTRUCT f : Σ*  Σ*
f: (M,w)  M’w where M’w (s) = accept if s = 0n1n
M(w) otherwise
So, L (M’w) = Σ* if M(w) accepts
{0n1n} if not
So, (M, w ) ATM  M’w  REGTM

Is REG SEMI-DECIDABLE?
 ATM = { (M,w) | M is a TM that accepts string w }
REGTM = { M | M is a TM and L(M) is regular}

CLAIM:  ATM m REGTM So, REG NOT SEMI-DECIDABLE

CONSTRUCT f : Σ*  Σ*
f: (M,w)  M”w where M”w (s) = accept if s = 0n1n
and M(w) accepts
Loop otherwise
So, L (M’w) = {0n1n} if M(w) accepts
 if not
So, (M, w )  ATM  M”w  REGTM

So, REG NOT SEMI-DECIDABLE

 ETM = { M | M is a TM and L(M) =  }
EQTM = {( M, N) | M, N are TMs and L(M) =L(N)}

CLAIM: ETM m EQTM So EQTM is UNDECIDABLE

CONSTRUCT f : Σ*  Σ*
f: M  (M, M  ) where M  (s) = Loops

So, M E TM  (M, M  )  EQTM

Is EQTM SEMI-DECIDABLE? NO, since,

 ATM m ETM m EQTM

 ATM = { (M,w) | M is a TM that accepts string w }
ALLPDA = { P | P is a PDA and L(P) = Σ* }

CLAIM: ATM m  ALLPDA  ATM m ALLPDA

CONSTRUCT f : Σ*  Σ*

f: (M,w)  Pw where
Pw (s) = accept iff s is NOT an accepting computation of M(w)

So, (M, w )  ATM  Pw  ALLPDA

So, (M, w ) ATM  Pw   ALLPDA

 COMPUTATION HISTORIES
An accepting computation history is a
sequence of configurations C1,C2,…,Ck, where
1. C1 is the start configuration,
2. Ck is an accepting configuration,
3. Each Ci follows from Ci-1
An rejecting computation history is a
sequence of configurations C1,C2,…,Ck, where
1. C1 is the start configuration,
2. Ck is a rejecting configuration,
3. Each Ci follows from Ci-1

M accepts w if and only if there exists an accepting

computation history that starts with C1=q0w
P will recognize all strings (read as sequences
of configurations) that:
1. Do not start with C1
2. Do not end with an accepting configuration
3. Where some Ci does not properly yield Ci+1

ε,ε → ε ε,ε → ε

ε,ε → ε

Non-deterministic checks for 1, 2, and 3.

 x → x, L
2n 0 → 0, L
{0 |n≥0}
q2
 → , R
 → , L
x → x, R x → x, R

q0 q1 q3
0 → , R 0 → x, R
x → x, R
 → , R 0 → 0, R
 → , R 0 → x, R

qreject qaccept q4

x → x, R
 → , R
 x → x, L
2n q 0000
0 →0 0, L
{0 |n≥0}
q2 q1000
 → , R xq300
 → , L
x → x, R x0qx4→
0 x, R

q0 q1 x0xq
q 3
3
0 → , R 0 → x, R x0q2x
x → x, R xq 0x0, R
 → , R 0 2→
 → , R 0 → x, R
q2x0x
qreject qaccept qq24x0x

x → x, R
 → , R
 P recognizes all strings except:

#C1# C2R #C3 #C4R #C5 #C6R #….# Ck

If k is odd, put Ck on stack and see if Ck+1R

follows properly:
For example,
If =uaqibv and  (qi,b) = (qj,c,R),
then Ck properly yields Ck+1  Ck+1 = uacqjv
 P recognizes all strings except:

#C1# C2R #C3 #C4R #C5 #C6R #….# Ck

If k is odd, put Ck on stack and see if Ck+1R

follows properly:

If =uaqibv and  (qi,b) = (qj,c,L),

then Ck properly yields Ck+1  Ck+1 = uqjacv
 P recognizes all strings except:

#C1# C2R #C3 #C4R #C5 #C6R #….# Ck

If k is even, put CkR on stack and see if Ck+1

follows properly.
 q00000
0 0 0 q1 
q1000
0 xq300
0 x0q40
0 ODD
x0xq3
0
x0q2x
q0
xq20x
q2x0x
:
#q00000#000q1#xq300#0q40x #x0xq3# ... #
 q00000
0 0 0 q1 
q1000
0 xq300
0 x0q40
0 ODD
x0xq3
0
x0q2x
q0
xq20x
q2x0x
:
#q00000#000q1#xq300#0q40x #x0xq3# ... #
 q00000
0 0 0 q1 
q1000
0 xq300
0 x0q40
0 ODD
x0xq3
0
x0q2x
q0
xq20x
q2x0x
:
#q00000#000q1#xq300#0q40x #x0xq3# ... #
 q00000
 x q3 0 0
q1000
 xq300
q1 x0q40
0 EVEN
x0xq3
0
x0q2x
0
xq20x
q2x0x
:
#q00000#000q1#xq300#0q40x #x0xq3# ... #
 q00000
 x q3 0 0
q1000
 xq300
q1 x0q40
0 EVEN
x0xq3
0
x0q2x
0
xq20x
q2x0x
:
#q00000#000q1#xq300#0q40x #x0xq3# ... #
THE POST CORRESPONDENCE
PROBLEM
 THE PCP GAME

ba a b b

a ab bcb a
aaa a a c

a c aa a
b a ca abc

ca ab a c
abc ca acc

ab a ca
 GENERAL RULE #1
If every top string is longer than the
corresponding bottom one, there can’t be a match
caa acc b aab c

a a b aa a
 GENERAL RULE #2
If there is a domino with the same string on the
top and on the bottom, there is a match
POST CORRESPONDENCE PROBLEM
Given a collection of dominos, is there a match?
PCP = { P | P is a set of dominos with a match }

PCP is undecidable!
 THE FPCP GAME
… is just like the PCP game except that a
match has to start with the first domino
 FPCP

aaa a a c

a c aa a
 FPCP

ba a b b

a ab bcb a
Theorem: FPCP is undecidable
Proof: Assume machine C decides FPCP
We will show how to use C to decide ATM
Given (M,w)
we will construct a set of
dominos P where a match is
an accepting computation caa aba a
history for M on w P= …
c bb d

P has a match?
 x → x, L
2n 0 → 0, L
{0 |n≥0}
q2
 → , R
 → , L
x → x, R x → x, R

q0 q1 q3
0 → , R 0 → x, R
x → x, R
 → , R 0 → 0, R
 → , R 0 → x, R

qreject qaccept q4

x → x, R
 → , R
 x → x, L
2n q 0000
0 →0 0, L
{0 |n≥0}
q2 q1000
 → , R xq300
 → , L
x → x, R x0qx4→
0 x, R

q0 q1 x0xq
q 3
3
0 → , R 0 → x, R x0q2x
x → x, R xq 0x0, R
 → , R 0 2→
 → , R 0 → x, R
q2x0x
qreject qaccept qq24x0x
#q00000#q1000#xq300#x0q40#x0xq3# ... #
:
x → x, R
 → , R
Given (M,w), we will construct an
instance P of FPCP in 7 steps
STEP 1
#
Put into P
#q0w1w2…wn#

START
STEP 2
qa
If (q,a) = (p,b,R) then add
bp

STEP 3
cqa
If (q,a) = (p,b,L) then add for all c  Γ
pcb

RULES
 x → x, L
2n 0 → 0, L
{0 |n≥0}
q2
 → , R
 → , L
x → x, R x → x, R

q0 q1 q3
0 → , R 0 → x, R
x → x, R
 → , R 0 → 0, R
 → , R 0 → x, R

qreject qaccept q4

x → x, R
 → , R
 x → x, L0q 0
2n 0 → 0, L 2
{0 |n≥0}
q2 q200
 → , R
 → , L
x → x, R xq20
x → x, R

q0 q2x0
q1 q3
0 → , R 0 → x, R
q20
x → x, R
 → , R 0 → 0, R
 → , R 0 → x, R q20

qreject qaccept 0q3

q4
xq3 q3
# q00 q10
…
#q00000# q1 xq3 q20 q2x x → x, R
q2
 → , R
STEP 4
a
add for all a  Γ
a

STEP 5
# #
add
# #

CONTINUE
STEP 4
a
add for all a  Γ
a

STEP 5
# #
add
# #

STEP 6
aqacc qacca
add for all a  Γ
qacc qacc
 # q00 q10 q1x q0x q0 q1 q2
#q00000# q1 xq3 xq1 xqr qr qa q1

q3x q30 q40 q4x q4 0q20 q20 xq20

xq3 0q4 xq3 xq4 qr q200 q20 q2x0

0q3 xq3 q3 0q3x xq3x q3x x 0 

q20 q2x q2 q20x q2xx q2x x 0 

# # 0qacc qacc0 xqacc qaccx qacc qacc

# # 0 0 x x x x

 q10 0 0

 xq3 0 0
STEP 7
qacc##
add
#

END
 0 → 0, R  → , R
q0 q1 qaccept

0 → 0, R
 → , R
qreject

# q00 q10 q0 q1 0 

#q00# 0q1 0qrej qrej qacc 0 

# # qacc 0qacc qacc qacc0 qacc##

# # qacc qacc qacc qacc #

# q00 # 0 q1 # 0 qacc # 0qacc #

#q00# 0q1 # 0 qacc # 0 qacc # qacc #

 Given (M,w), we can construct an
instance of FPCP that has a match if
and only if M accepts w
Can convert an instance of FPCP into one of PCP:
Let u = u1u2…un, define:
u =  u1  u2  u3  …  un
u = u1  u2  u3  …  un 
u =  u1  u2  u3  …  un 

t1 t2 tk
FPCP: …
b1 b2 bk

t1 t1 t2 tk 

PCP: …
b1 b1 b2 bk 
 Given (M,w), we can construct an
instance of PCP that has a match if
and only if M accepts w
 For Next Time
Read Chapters 5.2 and 5.3 of the book for next time