CS Name: 341 Practice Final Exam 1. Please write neatly. You will lose points if we cannot figure out what you are saying. 2. Whenever you answer a question with a machine or a grammar, add comments to help us figure out what you are trying to do. 3. DO NOT WRITE JUNK and hope for partial credit. If you are trying to prove something and you know that you havent got it right, say so. That may get you partial credit. But if you give the impression that you think that junk is nonjunk, you wont get points.
1a b c d e f g 2 3 4 5 Total
20 20 20 20 20 20 20 10 30 12 15 207
(1) For each of the following languages: (i.) (4 points) Determine the appropriate category, as listed below. (ii.) (8 points) Prove that the language is in the category you have specified, except as noted below, in which case these points will be assigned to part iii. You can do this part by writing an appropriate grammar (or regular expression), exhibiting an appropriate recognizing machine, using closure properties, or by showing that the language is finite. What I mean by exhibit a recognizing machine is: For an FSM: Draw it. For a PDA: Draw it, but if it is very complicated, also provide a description of how it works. We will give partial credit for the description even if the details of the machine are missing or wrong. For a Turing machine: Describe an algorithm in clear English. It need not be specifically a Turing Machine program. Any clear algorithm is acceptable. (iii.) (8 points) Prove that the language is not in the next most restricted category, except as noted below, in which case these points will be assigned to part ii. Assume the following language categories: A. L is regular. (In this case, you can skip part iii.) B. L is not regular but is context free C. L is not context free but is decidable (In this case, if L is a set of strings that include descriptions of machines (FSMs, PDAs or TMs), you do not need to prove that it is not context free.) D. L is not in D but is in SD. E. L is not in SD. (In this case, you can of course skip part ii.) You may take as theorems that the following languages are not decidable: H = {<M, w> : TM M halts on input string w} H = {<M> : TM M halts on the empty tape} HANY = {<M> : there is any string on which TM M halts} The corresponding languages A, A, and AANY. You may take as theorems that the following languages are not semidecidable: H = {<M, w> : TM M does not halt on input string w} HANY = {<M> : there does not exist any string on which M halts} HALL = {<M> : TM M halts on all inputs} EqTMs = {<Ma, Mb> : L(Ma) = L(Mb)} The corresponding languages A, AANY and AALL. You may not use Rices Theorem for these problems. To get full credit for any reduction proof, you must justify, in detail, why the reduction is correct. So purely copying and pasting a standard reduction will not get full credit even if it happens to work. Remember that: If S is a set, |S| is the cardinality of S. If w is a string, |w| is the length of w. #a(w) is the number of as in the string w.
(a) L = {<M, w> : M moves right exactly twice while operating on w}
D. If it can move right only twice, then M can read only the first two input characters. More generally, at any point in its computation, the only things that can affect its future behavior are: The contents of the two tape squares to the right of the read/write head, which may contain any element of . The contents of the square under the read/right head, which may also contain any element of . The contents of the two tape squares to the left of the read/write head, which may contain any element of . The rest of the tape to the left, but every one of these squares must contain a blank, so theres no information here. The state of M. So the number of distinct configurations of M is maxconfigs = ||5 |K|. If M ever enters a configuration a second time, it will do the same thing that it did the first time. So the following algorithm decides L: 1. Run M on w for maxconfigs + 1 steps or until it halts or moves right three times. Keep track of how many times it moves right. Note that if it didnt naturally halt, it is in an infinite loop. 2. If it halted and moved right exactly twice, accept. 3. If it halted and moved right some other number of times, reject. 4. If it moved right three times, reject. 5. If it didnt move right at all, reject. It is in a loop and will never move right. 6. If it moved right exactly once, reject. Either that one move is outside the loop, in which case there wont be any more, or its inside the loop and there will be an infinite number of additional ones. 7. If it moved right twice, we need to find out whether those moves were inside the loop or preceded entry into the loop. So continue running M for another maxconfigs steps. 8. If the total number of rightward moves is still two, accept. 9. Otherwise reject.
(b) L = {wx : |w| = 2|x| w a+b+ x a+b+}
Context-free, not regular. L can be accepted by a PDA M that pushes one character for each a and b in w and then pops two characters for each a and b in x. L is not regular, which we show by pumping. Note that the boundary between the w region and the x region is fixed; its immediately after the last b in the first group. Choose to pump the string w = a2kb2kakbk. y = ap, for some nonzero p. Pump in or out. The length of w changes but the length of x does not. So the resulting string is not in L.
(c) L = {<Ma, Mb> : if Ma does not accept then Mb rejects }
SD/D: Note that L is equivalent to {<Ma, Mb> : Ma accepts or Mb rejects }. The following semidecides algorithm L: Run both machines on in parallel. If either Ma accepts or Mb rejects, halt and accept. Proof not in D: R is a reduction from H = {<M, w> : TM M halts on w} to L, defined as follows: R(<M, w>) = 1. Construct the description of M#(x) that, on any input, immediately accepts. 2. Construct the description of M##(x) that operates as follows: 2.1 Erase the tape. 2.2 Write w on the tape. 2.3 Run M on w. 2.4 Accept. 3. Return <M##, M#>. If Oracle exists and decides L, then C = Oracle(R(<M, w>)) decides H. R can be implemented as a Turing machine. And C is correct. Note that M# rejects nothing. M## accepts everything or nothing, depending on whether M halts on w. So: <M, w> H: M halts on w so M## accepts everything, including . So Oracle accepts. <M, w> H: M doesnt halt on w so M## accepts nothing, including . M# rejects nothing. So Oracle rejects. But no machine to decide H can exist, so neither does Oracle.
(d) L = {<M> : M rejects at least two even length strings}
SD/D: The following algorithm semidecides L: Run M on the even length strings in * in lexicographic order, interleaving the computations. As soon as two such computations have rejected, halt. Proof not in D: R is a reduction from H = {<M, w> : TM M halts on w} to L, defined as follows: R(<M, w>) = 1. Construct the description of M#(x) that, on input x, operates as follows: 1.1. Erase the tape. 1.2. Write w on the tape. 1.3. Run M. 1.4. Reject. 2. Return <M#>. If Oracle exists and decides L, then C = Oracle(R(<M, w>)) decides H: <M, w> H: M halts on w so M# rejects everything and thus rejects at least two even length strings, so Oracle accepts. <M, w> H: M doesnt halt on w so M# doesnt halt and thus rejects nothing and so does not reject at least even length two strings. Oracle rejects. But no machine to decide H can exist, so neither does Oracle.
(e) L = {w = xyxR : x {0, 1}+, y {0, 1}*}
Regular. There is no reason to let x be more than one character. So all that is required is that the string have at least two characters and the first and last must be the same. L = (0 (0 1)* 0) (1 (0 1)* 1).
(f) L = {<M> : L(M) is not regular}
SD: R is a reduction from H = {<M, w> : TM M does not halt on w} to L, defined as follows: R(<M, w>) = 1. Construct the description of M#(x) that operates as follows: 1.1. Save its input x on a second tape. 1.2. Erase the tape. 1.3. Write w. 1.4. Run M on w for |x| steps or until it halts. 1.5. If M would have halted, then loop. 1.6. Else: if x anbn, accept. Otherwise reject. 2. Return <M#>. If Oracle exists and semidecides L, then C = Oracle(R(<M, w>)) semidecides H: <M, w> H: M does not halt on w, so M# always gets to step 1.6. So L(M#) = anbn, which isnt regular. Oracle accepts. <M, w> H: M halts on w. Suppose it does so in k steps. Then, for all strings of length k or more, M# loops at step 1.5. So L(M#) is finite and thus regular. So Oracle does not accept. But no machine to semidecide H can exist, so neither does Oracle.
(g) L = {wxw : |w| = 2|x|, w {a, b}*, x {c}*}
Not context-free. We prove it using the Pumping Theorem. Let w = a2kcka2k.
(2) Consider the following Turing Machine M, described in our macro language: >R L a RbL h Give a short English ...