5. Reducibility

1. 5. Reducibility • Reductions • Example, formal definition • Computable functions • Mapping reducibility • Undecidable problems • computation histories • Rice’s Theorem • Post Correspondence Problem • a non-RE and non-co-RE problem

2. Reductions • Given a new problem NEW, want to determine if it is undecidable • prove from scratch that the problem is undecidable (dream up a diag. argument) • show how to transform a known undecidable problem OLD into NEW so that solution to NEW can be used to solve OLD • A reduction is a way of converting one problem into another such that a solution to the second problem can be used to solve the first problem.

3. Reductions Reductions are one of the most important and widely used techniques in theoretical Computer Science. • especially for proving problems “hard” • often difficult to do “from scratch” • sometimes not known how to do from scratch • reductions allow proof by giving an algorithm to perform the transformation

4. Example Reduction • Try to prove undecidable: ATM = {<M, w> | M accepts input w} • We know this language is undecidable: HALT = {<M, w> | M halts on input w} • Idea: • suppose ATM is decidable • show that we can use ATM to decide HALT • conclude HALT is decidable. Contradiction. reduction

5. Example Reduction • Deciding HALT using a procedure that decides ATM (“reducing HALT to ATM”). • on input <M, w> • check if <M, w> ATM • if yes, then M halts on w; ACCEPT • if no, then M either rejects w or it loops in w • construct M’ by swapping qaccept/qreject in M • check if <M’, w> ATM • if yes, then M’ accepts w, so M rejects w; ACCEPT • if no, then M neither accepts nor rejects w; REJECT

6. Another Example • Try to prove undecidable: ETM = {<M> | L(M) = Ø} • which problem should we reduce from? • HALT = {<M, w> | M halts on input w} • ATM = {<M, w> | M accepts input w} • Proof: • suppose ETM is decidable • we showed how to use ETM to decide ATM • conclude ATM is decidable. Contradiction.

7. Another Example • On input <M, w>: • construct TM M’ from description of M • on input x, if x  w, then reject • else simulate M on x, and accept if M does. • check if M’ ETM • if no, M must accept w; ACCEPT • if yes, M cannot accept w; REJECT

8. Definition of Reduction • Can you reduce co-HALT to HALT? • We know that HALT is RE • Does this show that co-HALT is RE? • recall, we showed co-HALT is not RE • our notion of reduction cannot distinguish complements

9. Definition of Reduction • More refined notion of reduction: • “many-one” reduction (commonly) • “mapping” reduction (book) A B f yes yes reduction from language A to language B f no no

10. Definition of Reduction A B f • function f should be computable Definition: f : Σ*→ Σ* is computable if there exists a TM Mf such that on every wΣ* Mf halts on w with f(w) written on its tape. yes yes f no no

11. Definition of Reduction Definition: A is mapping reducible to B, written A ≤m B, if there is a computable function f such that for all w w  A  f(w)  B • “yes maps to yes and no maps to no” means: w  A maps to f(w)  B & w  A maps to f(w)  B • f is called the reduction of A to B

12. Using Reductions Theorem: if A ≤m B and B is decidable, then A is decidable Proof: • decider for A: on input w, compute f(w), run decider for B, do whatever it does. • Main use:given language NEW, prove it isundecidableby showingOLD ≤m NEW, where OLD is known to beundecidable • common to reduce in wrong direction!

13. Using Reductions Theorem: if A ≤m B and B is RE, then A is RE Proof: • TM for recognizing A: on input w, compute f(w), run TM that recognizes B, do whatever it does. • Main use:given language NEW, prove it isnot RE by showingOLD ≤m NEW, where OLD is known to benot RE.

14. Mapping Reduction Example • ETM is undecidable. Consider: co-ETM = {<M> | L(M) Ø} • f(<M, w>) = <M’> • where M’ is TM that • on input x, if x  w, then reject • else simulate M on x, and accept if M does • f clearly computable f yes yes f no no co-ETM ATM

15. Mapping Reduction Example • f(<M, w>) = <M’> • where M’ is TM that • on input x, if x  w, then reject • else simulate M on x, and accept if M does • f clearly computable f yes yes • yes maps to yes? • if <M, w>  ATM, then f(M, w)  co-ETM • no maps to no? • if <M, w>  ATM, then f(M, w)  co-ETM f no no co-ETM ATM

16. Undecidable Problems Theorem: The language REGULAR = {<M> | M is a TM and L(M) is regular} is undecidable. Proof: • reduce from ATM (i.e. show ATM ≤m REGULAR) • what should f(<M, w>) produce?

17. Undecidable Problems Proof: • f(<M, w>) = <M’> described below • is f computable? • YES maps to YES? • <M, w>  ATM  f(M, w)  REGULAR • NO maps to NO? • <M, w>  ATM  f(M, w)  REGULAR • M’ on input x: • if x has form 0n1n, accept • else simulate M on w and accept if M accepts w

18. Computation Histories • Recall configuration of a TM: string uqv with u,v  *, q  Q • The sequence of configurations M goes through on input w is a computation history of M on input w • may be accepting, or rejecting • reserve the term for halting computations • nondeterministic machines may have several computation histories for a given input.

19. Linear Bounded Automata LBA definition: TM that is prohibited from moving head off right side of input. • machine prevents such a move, just like a TM prevents a move off left of tape • How many possible configurations for a LBA M on input w with |w| = n, m states, and p = || ? • counting gives: mnpn

20. Dec. and Undec. Problems • two problems we have seen with respect to TMs, now regarding LBAs: • LBA acceptance: ALBA = {<M, w> | LBA M accepts input w} • LBA emptiness: ELBA = {<M> | LBA M has L(M) = Ø} • Both decidable? both undecidable? one decidable?

21. Dec. and Undec. Problems Theorem: ALBA is decidable. Proof: • input <M, w> where M is a LBA • key: only mnpn configurations • if M hasn’t halted after this many steps, it must be looping forever. • simulate M for mnpn steps • if it halts, accept or reject accordingly, • else reject since it must be looping

22. Dec. and Undec. Problems Theorem: ELBA is undecidable. Proof: • reduce from co-ATM (i.e. show co-ATM ≤m ELBA) • what should f(<M, w>) produce? • Idea: • produce LBA B that accepts exactly the accepting computation histories of M on input w

23. Dec. and Undec. Problems Proof: • f(<M, w>) = <B> described below • is B an LBA? • is f computable? • YES maps to YES? • <M, w>  co-ATM  f(M, w)  ELBA • NO maps to NO? • <M, w>  co-ATM  f(M, w)  ELBA • on input x, check if x has form • #C1#C2#C3#...#Ck# • check that C1 is the start configuration for M on input w • check that Ci1 Ci+1 • check that Ck is an accepting configuration for M

24. Dec. and Undec. Problems • two problems regarding Context-Free Grammars: • does a CFG generate all strings: ALLCFG = {<G> | G is a CFG and L(G) = Σ*} • CFG emptiness: ECFG = {<G> | G is a CFG and L(G) = Ø} • Both decidable? both undecidable? one decidable?

25. Dec. and Undec. Problems Theorem: ALLCFG is undecidable. Proof: • reduce from co-ATM (i.e. show co-ATM ≤m ALLCFG) • what should f(<M, w>) produce? • Idea: • produce CFG G that generates all strings that are notaccepting computation histories of M on w

26. Dec. and Undec. Problems Proof: • build a NPDA, then convert to CFG • want to accept strings not of this form, #C1#C2#C3#...#Ck# plus strings of this form but where • C1 is not the start config. of M on input w, or • Ck is not an accept config. of M on input w, or • Ci does not yield in one step Ci+1 for some i

27. Dec. and Undec. Problems Proof: • our NPDA nondeterministically checks one of: • C1 is not the start config. of M on input w, or • Ck is not an accept config. of M on input w, or • Ci does not yield in one step Ci+1 for some i • input has fewer than two #’s • to check third condition: • nondeterministically guess Ci starting position • how to check that Cidoesn’t yield in 1 step Ci+1?

28. Dec. and Undec. Problems Proof: • checking: • Ci does not yield in one step Ci+1 for some i • push Ci onto stack • at #, start popping Ci and compare to Ci+1 • accept if mismatch away from head location, or • symbols around head changed in a way inconsistent with M’s transition function. • is everything described possible with NPDA?

29. Dec. and Undec. Problems Proof: • Problem: cannot compare Ci to Ci+1 • could prove in same way that proved {ww: w Σ*} not context-free • recall that {wwR: w Σ*} is context-free • free to tweak construction of G in the reduction • solution: write computation history: #C1#C2R#C3#C4R...#Ck#

30. Dec. and Undec. Problems Proof: • f(<M, w>) = <G> equiv. to NPDA below: • on input x, accept if not of form: • #C1#C2R#C3#C4R...#Ck# • accept if C1 is the not the start configuration for M on input w • accept if check that Ci does not yield in one step Ci+1 • accept if Ck is not an accepting configuration for M • is f computable? • YES maps to YES? • <M, w>  co-ATM  f(M, w)  ALLCFG • NO maps to NO? • <M, w>  co-ATM  f(M, w)  ALLCFG

31. Rice’s Theorem • We have seen that the following properties of TM’s are undecidable: • TM accepts string w • TM halts on string w • TM accepts the empty language • TM accepts a regular language • Can we describe a single generic reduction for all these proofs? • Yes. Every property of TMs is undecidable!

32. Rice’s Theorem • A TM property is a language P for which • if L(M1) = L(M2) then <M1>  P iff <M2>  P • TM property P is nontrivial if • there exists a TM M1 for which <M1>  P, and • there exists a TM M2 for which <M2>  P. Rice’s Theorem: Every nontrivial TM property is undecidable.

33. Rice’s Theorem • The setup: • let TØ be a TM for which L(TØ) = Ø • technicality: if <TØ>  P then work with property co-P instead of P. • conclude co-P undecidable; therefore P undec. due to closure under complement • so, WLOG, assume <TØ>  P • non-triviality ensures existence of TM M1 such that <M1>  P

34. Rice’s Theorem Proof: • reduce from ATM (i.e. show ATM ≤m P) • what should f(<M, w>) produce? • f(<M, w>) = <M’> described below: • f computable? • YES maps to YES? • <M, w>  ATM  L(f(M, w)) = L(M1) f(M, w)  P • M’ on input x, • accept iff M accepts w and M1 accepts x • (intersection of two RE languages)

35. Rice’s Theorem Proof: • reduce from ATM (i.e. show ATM ≤m P) • what should f(<M, w>) produce? • f(<M, w>) = <M’> described below: • NO maps to NO? • <M, w>  ATM  L(f(M, w)) = L(TØ) f(M, w)  P • M’ on input x, • accept iff M accepts w and M1 accepts x • (intersection of two RE languages)

36. Post Correspondence Problem • There are many undecidable problems unrelated to TMs and automata • classic example: Post Correspondence Problem PCP = {<(x1, y1), (x2, y2), …, (xk, yk)> | xi, yi Σ* and there exists (a1, a2, …, an) for which xa1xa2…xan= ya1ya2…yan}

37. Post Correspondence Problem PCP = {<(x1, y1), (x2, y2), …, (xk, yk)> | xi, yi Σ* and there exists (a1, a2, …, an) for which xa1xa2…xan= ya1ya2…yan} b ca a ab a ab b ca ca a a ab abc c ca a abc c abcaaabc= abcaaabc “tiles” “match”

38. Post Correspondence Problem Theorem: PCP is undecidable. Proof: • reduce from ATM (i.e. show ATM ≤m PCP) • two-step reduction makes it easier • first, show ATM ≤m MPCP (MPCP = “modified PCP”) • next, show MPCP≤m PCP

39. Post Correspondence Problem MPCP = {<(x1, y1), (x2, y2), …, (xk, yk)> | xi, yi Σ* and there exists (a1, a2, …, an) for which x1xa1xa2…xan= y1ya1ya2…yan} Proof of MPCP≤m PCP: • notation: for a string u = u1u2u3…um • u means the string u1u2u3u4…um • u means the string u1u2u3u4…um • umeans the string u1u2u3u4…um

40. Post Correspondence Problem Proof of MPCP≤m PCP: • given an instance (x1, y1), …, (xk, yk)of MPCP • produce an instance of PCP: (x1, y1), (x1, y1), (x2, y2), …, (xk, yk),(, ) • YES maps to YES? • given a match in original MPCP instance, can produce a match in the new PCP instance • NO maps to NO? • given a match in the new PCP instance, can produce a match in the original MPCP instance

41. Post Correspondence Problem • YES maps to YES? • given a match in original MPCP instance, can produce a match in the new PCP instance x1 y1 x4 y4 x5 y5 x2 y2 x1 y1 x3 y3 x4 y4 x4 y4 x1 y1 x4 y4 x5 y5 x2 y2 x1 y1 x3 y3 x4 y4 x4 y4  

42. Post Correspondence Problem can’t match unless start with this tile • NO maps to NO? • given a match in the new PCP instance, can produce a match in the original MPCP instance x1 y1 x4 y4 x5 y5 x2 y2 x1 y1 x3 y3 x4 y4 x4 y4   “” symbols must align x1 y1 x4 y4 x5 y5 x2 y2 x1 y1 x3 y3 x4 y4 x4 y4 can only appear at the end

43. Post Correspondence Problem Proof of ATM ≤m MPCP: • given instance of ATM: <M, w> • idea: a match will record an accepting computation history for M on input w • start tile records starting configuration: • add tile(#, #q0w1w2w3…wn#) # #q0w1w2…wn# # #C1# =

44. Post Correspondence Problem # # q0w1w2…wn# ? ? ? ? ? ? #C1# #C1#C2# … = • tiles for head motions to the right: • for all a,b   and all q, r  Q with q  qreject, if δ(q, a) = (r, b, R), add tile(qa, br) • tiles for head motions to the left: • for all a,b,c   and all q, r  Q with q  qreject,ifδ(q, a) = (r, b, L), add tile(cqa, rcb) qa br cqa rcb

45. Post Correspondence Problem # # q0w1w2…wn# ? ? ? ? ? ? #C1# #C1#C2# … = • tiles for copying (not near head) • for all a  , add tile(a, a) • tiles for copying # marker • add tile(#, #) • tiles for copying # marker and adding _ to end of tape • add tile(#, _#) a a # # # _#

46. Post Correspondence Problem # #uaqacceptv# ? ? ? ? #uaqacceptv# #uaqacceptv#uqacceptv# … = • tiles for deleting symbols to left of qaccept • for all a  , add tile(aqaccept, qaccept) aqaccept qaccept

47. Post Correspondence Problem # #uqaccept# ? ? ? ? #uqacceptav# #uqacceptav#uqacceptv# … = • tiles for deleting symbols to right of qaccept • for all a  , add tile(qaccepta, qaccept) qaccepta qaccept

48. Post Correspondence Problem # #qaccept# ? ? ? ? #qaccept## #qaccept## … = • tiles for completing the match • for all a  , add tile(qaccept##, #) qaccept## #

49. Post Correspondence Problem • YES maps to YES? • by construction, if M accepts w, there is a way to assemble the tiles to achieve this match: • NO maps to NO? • sketch: at any step if the “intended” next tile is not used, then it is impossible to recover and produce a match in the end (case analysis) #C1#C2#C3#...#Cm# #C1#C2#C3#...#Cm# where #C1#C2#C3#...#Cm#is an accepting computation history

50. Post Correspondence Problem We have proved: Theorem: PCP is undecidable. by showing: • ATM ≤m MPCP • MPCP≤m PCP • conclude ATM ≤m PCP