Undecidable problems for CFGs The Chinese University of Hong Kong Fall 2010 CSCI 3130: Formal languages and automata theory Undecidable problems for CFGs Andrej Bogdanov http://www.cse.cuhk.edu.hk/~andrejb/csc3130

Decidable vs. undecidable “DFA M accepts w” “TM M accepts w” “CFG G generates w” “TM M halts on w” “DFAs M and M’ accept same inputs” “TM M accepts some input” “TM M and M’ accept same inputs” “CFG G generates all inputs” “CFG G is ambiguous” more? ?

Representing computations L1 = {w%w: w ∈{a, b}*} a/aR b/bR x/xR %/%R a/aL abbaa%abbaa q0 q1 q2 b/bL a/aL a/xL b/bL xbbaa%abbaa q1 x/xR x/xL a/xR xbbaa%abbaa ... q1 %/%R ☐/☐R %/%R q0 q7 qa q5 q6 b/xR b/xL xbbaa%abbaa q2 q3 q4 xbbaa%xbbaa q5 %/%R ... xxxxx%xxxxx qa a/aR x/xR b/bR x/xR

Configurations A configuration consists of the current state, the head position, and tape contents configuration … a b ☐ q1 abq1a q1 qacc a/bR … a b ☐ qacc abbqacc

Computation histories a/aR b/bR x/xR q0a0b0%0a0b0 x0q1b0%0a0b0 x0b6q1%0a0b0 x0b6%0q2a0b0 x0b6q5%0x1b0 x0q6b0%0x0b0 %/%R a/aL q1 q2 b/bL a/aL a/xL b/bL x/xR x/xL a/xR %/%R ☐/☐R %/%R q0 q7 qa q5 q6 b/xR b/xL ... q3 q4 %/%R x0x0%0x0x0q7 x0x0%0x0x0☐aqa a/aR x/xR b/bR x/xR computation history

Computation histories as strings If M halts on w, the computation history of (M, w) is the sequence of configurations C1, ..., Cl that M goes through on input w. q0a0b0%0a0b0 x0q1b0%0a0b x0x0%0x0x0q7 x0x0%0x0x0qa ... #q0ab%ab#xq1b%ab# . . . #xx%xx☐qa# C1 C2 Cl The computation history can be written as a string hist over alphabet ∪Q∪{#} accepting history: M accepts w qacc occurs in hist rejecting history: M rejects w qrej occurs in hist

Undecidable problems for CFGs ALLCFG = {〈G〉: G is a CFG that generates all strings} The language ALLCFG is undecidable. We will argue that If ALLCFG can be decided, so can ATM.

Undecidable problems for CFGs accept if G generates all strings reject if not accept if M rej/loops w construct G A 〈G〉 〈M, w〉 reject if M accepts w G generates all strings if M rejects or loops on w G fails to generate some string if M accepts w

Undecidable problems for CFGs G fails to generate some string 〈M, w〉 construct G 〈G〉 M accepts w The alphabet of G will be ∪Q∪{#} G will generate all strings except the computation history of (M, w), if it is accepting First we construct a PDA P, then convert it to CFG G

Undecidability via computation histories candidate computation history hist of (M, w) P accept everything except accepting hist #q0ab%ab#xq1b%ab# . . . #xx%xx☐qa# reject P: On input hist, // try to spot a mistake in hist If hist is not of the form #w1#w2#...#wk#, accept. q0 e If w1 ≠ q0w or wk does not contain qa, accept. If two consecutive blocks wi#wi+1 do not follow from the transitions of M, accept. Otherwise, hist is an accepting history, so reject.

Computation is local #0q0a0b0%0a0b0 #0x0q1b0%0a0b0 #0x0b6q1%0a0b0 a/aR b/bR x/xR #0q0a0b0%0a0b0 #0x0q1b0%0a0b0 #0x0b6q1%0a0b0 #0x0b6%0q2a0b0 #0x0b6q5%0x1b0 #0x0q6b0%0x0b0 %/%R a/aL q1 q2 b/bL a/aL a/xL b/bL x/xR x/xL a/xR %/%R ☐/☐R %/%R q0 q7 qa q5 q6 b/xR b/xL ... q3 q4 %/%R #0x0x0%0x0x0q7 #0x0x0%0x0x0☐aqa a/aR x/xR b/bR x/xR Changes between configurations always occur around the head

Valid and invalid transition windows valid windows invalid windows … 6a3b0x0 … … 0a6b0x0 …0 … 6q2a0b0 … … 0a6b0q2 …0 … 6a3q2a0 … … 0q5a6x0 …0 … 6q2q2a0 … … 0q2q2x3 …0 q2 a/xL … 6a3b0a0 … … 0a6b0q5 …0 … 6a3q2a0 … … 0q5a6b0 …0 q5 … 6a3a0☐0 … … 0x6a0☐0 …0 … 6a3q2a0 … … 0a6q5x0 …0

Implementing P If two consecutive blocks wi#wi+1 do not follow from the transitions of M, accept: #0x0b6%0q2a0b #0x0b6q5%0x1b For every position of wi: offset Remember offset from # in wi on stack Remember first row of window in state After reaching the next #: Pop offset from # from stack as you consume input Remember second row of window in state If window is invalid, accept; Otherwise reject.

Recap of computation history method ALLCFG = {〈G〉: G is a CFG that generates all strings} If ALLCFG can be decided, so can ATM. G accepts all strings except accepting computation histories of (M, w) We first construct a PDA P, then convert it to G 〈M, w〉 construct G 〈G〉

The Post Correspondence Problem Input: A set of tiles like this Given an infinite supply of such tiles, can you match top and bottom? bab cc c ab a ab baa a a baba bab e a ab baa a bab e c ab c ab bab cc a baba

Undecidability of PCP PCP = {〈T〉: T is a collection of tiles that contains a top-bottom match} The language PCP is undecidable. Proof: We will show that If PCP can be decided, so can ATM.

Undecidability of PCP 〈M, w〉 T (collection of tiles) M accepts w T contains a match Idea: Matches represent accepting histories #q0ab%ab#xq1b%ab#...#xx%xx☐qa# #q0ab%ab#xq1b%ab#...#xx%xx☐qa# e #q0ab%ab #q0a #xq1 b a % a b # xq1% x%q2 …

An assumption We will assume that one of the PCP tiles is marked as a starting tile Later we’ll see how to “simulate” the starting tile by an ordinary tile s bab cc c ab a ab baa a a baba

for each valid window with state qi in top middle Undecidability of PCP 〈M, w〉 T (collection of tiles) M accepts w T contains a match On input 〈M, w〉 we construct these tiles for PCP e #q0w s x1qix2 x3x4x5 for each valid window with state qi in top middle xx for all x in G∪{#} xqa qa ☐# qax ☐#qix1 ☐#x2x3 qa## #

Undecidability of PCP tile type purpose e #q0w s represents initial configuration represent valid transitions between configurations xx x1qix2 x3x4x5 add blank spaces before # if necessary ☐# ☐#qix1 ☐#x2x3 xqa qa qax qa## # complete match if computation accepts

Undecidability of PCP #q0a%ab#xq1%ab#...#xx%xxq7☐#xx%xx☐qa# accepting computation history #q0a b % ab# xq1b%ab#... #xx%x xq7☐ # #q0ab%ab #xq1 b % ab# ...#xx%xxq7☐ #xx%x x☐qa # s e #q0w x1qix2 x3x4x5 ☐#qix1 ☐#x2x3 ☐# xx

Undecidability of PCP Once the accepting state symbol occurs, the last two tiles can “eat up” the rest of the symbols #xx%xx ☐qa #xx%x xqa #xx%xqa#... # qa## #xx%xx☐qa #xx%xx qa #xx%x qa #...#qa # # xx xqa qa qax qa qa## #

for each valid window of this form Undecidability of PCP If M rejects on input w, then qrej appears on bottom at some point, but it cannot be matched on top If M loops on w, then matching keeps going forever s e #q0w a1qia3 b1b2b3 ☐#qia2 ☐#b1b2 ☐# xx xqa qa qax qa qa## # for each valid window of this form for all x in G∪{#}

Getting rid of the starting tile We assumed that one tile marked as starting tile We can remove assumption by changing tiles a bit s a aba ba bb b c cca a *a* *a*b*a b*a* *b*b b* *c c*c*a* *a  * “starting tile” begins with * “middle tiles” “ending tile” matches last *

Getting rid of the starting tile aba ba bb b c b c cca a *a* *a*b*a b*a* *b*b b* *c b* *c c*c*a* *a  * can only use as starting tile can only use to complete match

Ambiguity of CFGs AMB = {G: G is an ambiguous CFG} The language AMB is undecidable. We will argue that If AMB can be decided, so can PCP.

Ambiguity of CFGs T G Step 1: Number the tiles (collection of tiles) (CFG) If T can be matched, then G is ambiguous If T cannot be matched, then G is unambiguous Step 1: Number the tiles 1 2 3 bab cc c ab a ab

Ambiguity of CFGs T G Terminals: a, b, c, 1, 2, 3 Variables: S, T, B (collection of tiles) (CFG) Terminals: a, b, c, 1, 2, 3 Variables: S, T, B Productions: T → babT1 B → ccB1 T → cT2 B → abB2 T → aT3 B → abB3 bab cc c ab a 1 2 3 S → T | B

Ambiguity of CFGs T G Terminals: a,b,c,1,2,3 Variables: S, T, B 1 2 3 (collection of tiles) (CFG) Terminals: a,b,c,1,2,3 Variables: S, T, B 1 2 3 Productions: bab cc c ab a ab S → T | B T → babT1 T → cT2 T → aT3 T → bab1 T → c2 T → a3 B → ccB1 B → abB2 B → abB3 B → cc1 B → ab2 B → ab3

Ambiguity of CFGs Each sequence of tiles gives two derivations If the tiles match, these two derive the same string 1 2 2 bab cc c ab c ab S ⇒ T ⇒ babT1 ⇒ babcT21⇒ babcc221 S ⇒ B ⇒ ccB1 ⇒ ccabB21⇒ ccabab221

Ambiguity of CFGs T G ✓ ✓ Argue by contradiction: (collection of tiles) (CFG) ✓ If T can be matched, then G is ambiguous ✓ If T cannot be matched, then G is unambiguous Argue by contradiction: If G is ambiguous then ambiguity must look like this S T a1 n1 ai ni a2 n2 … B b1 m1 bj mj b2 m2 Then n1...ni = m1…mj So there is a match a1 b1 a2 b2 ai bi n1 n2 ni …