Question text is in black, solutions in blue.
Q1: 10 points Q2: 10 points Q3: 10 points Q4: 10 points Q5: 10 points Q6: 10 points Q7: 30+10 points Q8: 30 points Total: 120+10 points
If C is any class of computers, such as DFA's, CFG's, LBA's TM, strange variant TM's, etc.:
A queue machine (QM) is a deterministic machine with a finite state set and one additional memory organized as a queue. At any time step the QM sees the next input character and the character at the front of the queue. Its move is to dequeue that character, move to the next input character (if any), enqueue zero or more characters, and change its state. It has and accepting and a rejecting final state, and it may continue computing after finishing its input.
A right-end Turing machine (RETM) has one or more tapes, each of which has a $ as its leftmost character. The first tape has the input after the $, and the others (if any) have blanks. The head of each tape starts on the leftmost blank on its tape. The RETM must satisfy the following rule -- on each tape the head must always be either on the rightmost nonblank character of its tape or on the leftmost blank character of its tape.
Recall that if A and B are two languages, A is mapping reducible to B, written A ≤m B, if there exists a function f: Σ* → Σ* such that for any string w, w ∈ A ↔ f(w) ∈ B. The languages A and B are mapping equivalent, written A ≡m B, if both A ≤m B and B ≤m A are true.
A language A is Turing recognizable (TR) if it equals L(M) for some Turing machine M. A is Turing decidable if A = L(M) for some Turing machine M that always halts. A function f is Turing computable if there exists a Turing machine M such that for any string w, M when started on w halts with f(w) on its tape.
TRUE. (M, N) ∈ SUBDFA,DFA means
∀w: w ∈ L(M) → w ∈ L(N), or
¬∃w: w ∈ L(M) ∧ w ∉ L(N).
Build a DFA whose language is L(M) ∩ L(N)-bar, using the
product construction. This machine is in EDFA (proven to
be decidable in the book) if and only if (M, N) ∈ SUBDFA,DFA.
TRUE: Similarly to the Question 1 solution, (G, D) ∈
SUBCFG,DFA if and only if the language L(G) ∩
L(D)-bar is empty. It is shown in the solved exercise 2.18(a) of
Sipser that the intersection of a CFL and a regular language is a
CFL.
Since L(D)-bar is regular, L(G) ∩ L(D)-bar is a CFL and we can
construct its CFG. (We can run a PDA in parallel with a DFA, using
a PDA, and the constructions of Chapter 2 can give us a CFG for this
language. We can thus decide SUBCFG,DFA using a decider
for ECFG.
This was a hard question -- I don't remember whether I mentioned
that particular closure result in lecture.
FALSE. ETM is shown undecidable in the book. We can prove that ETM ≤m SUBTM,DFA. Our reduction function f takes (M) to (M, N∅), where N∅ is a DFA that always rejects. With this f, (M) ∈ ETM ↔ L(M) = ∅ ↔ L(M) ⊆ ∅ ↔ (M, N∅) ∈ SUBTM,DFA ↔ f((M)) ∈ SUBTM,DFA.
FALSE. We reduce the non-TR language ATM-bar to SUBTM,DFA. Given a Turing machine M and a string w, let f((M, w)) = (M', N∅, where again N∅ is a DFA that always rejects, and M' is a TM that on input x, ignores x and runs M on w. With this f, (M, w) ∈ ATM-bar ↔ w ∉ L(M) ↔ L(M') = ∅ ↔ L(M) ⊆ ∅ ↔ (M', N∅) ∈ SUBTM,DFA ↔ f((M, w)) ∈ SUBTM,DFA.
FALSE. A QM can simulate an ordinary one-tape TM. Thus we can reduce
the non-TD language ATM to AQM, proving that the
latter is not TD.
If c and c' are two consecutive configurations of an ordinary
one-tape TM, we want our QM to read c$ off of the queue and
simultaneously write c'$ to the queue. It does this by copying
characters that are away from the head and making small adjustments
to the three-letter string around the head, as in the proof that the
Post Correspondence Problem is undecidable. It must remember the
last character it dequeued before it enqueues it, in case the
following character is the head position.
The QM begins its simulation by enqueueing the character for the
start state, reading in the input and enqueueing
it, and enqueuing a $. Now the initial configuration of the TM is on
the queue. The QM now successively changes the queue to each
succeeding configuration of the TM, until or unless the TM accepts or
rejects.
TRUE. ALLCFG ≤m ATM-bar using the
following function f. Given any CFG G, f((G)) = (M, ε), where
M, on any input, checks all strings in Σ* for
membership in L(G) (using the decider for ACFG), accepting
if it finds a string that is not in L(G). Thus (G) ∈
ALLCFG ↔ L(G) = Σ* ↔ ∀w:
w ∈ L(G) ↔ ¬∃w: w ∉ L(G) ↔ M does not
accept ε ↔ (M, ε) ∈ ATM-bar.
ATM-bar ≤m ALLCFG using the
construction in Sipser that takes a Turing machine M and a string w,
and builds a grammar G such that L(G) is the set of all strings that
are not accepting computation histories of M on w. Then (M, w)
∉ ATM ↔ w ∉ L(M) ↔ ¬∃c:
ACH(M, w, c) ↔ L(G) = Σ* ↔ (G) ∈
ALLCFG.
On input (N), create a DFA D with L(D) = L(N) using the Subset
Construction. Then create a DFA D' with L(D') = L(D)-bar by
changing all final states in D to nonfinal and vice versa. Then
type-cast D' to an NFA N' and we have L(N') = L(N)-bar as desired.
Some people said that switching final and non-final states in
the NFA gave you an NFA for the complement -- it doesn't.
Let M be an arbitrary TM. The TM-complementer f, by assumption, would
map (M) to a TM description (M'), where L(M') = L(M)-bar. We can
build a decider M'' for L(M) using this assumption. On input w,
M'' creates M' and then runs M and M' in parallel on w, accepting
if M accepts and rejecting if M' accepts. Since L(M) ∪ L(M')
= Σ*, M'' always halts and is a decider.
We don't need the assuption that f is Turing computable,
because if f just exists, then f((M)) = (M') exists for any M, and
thus the M'' we defined exists and L(M) = L(M'') is a TD language.
The "fixed point version" of the Recursion Theorem says that if f is
Turing computable, there exists a TM M such that f((M)) = (M') and
L(M') = L(M). Since no language is its own complement, this f
cannot be a TM-complementer.
The ordinary version of the Recursion Theorem says that if this
Turing computable f existed, you could create a Turing machine M as
follows: On input w, obtain own description (M) by the Recursion
Theorem, compute (M') using f, and run M' on w. This forces L(M) =
L(M') and contradicts f being a TM-complementer.
Let U be the universal Turing machine, such that L(U) = ATM. If f were a TM-complementer, f((U)) would be the description of a TM M' such that L(M') would be ATM-bar. But ATM-bar is not Turing-recognizable and thus not the language of any TM.
The simple answer is that no CFG-complementer can exist, Turing
computable or not, because there are CFL's whose complements are not
CFL's.
For example, there is a grammar G whose language is the complement of
{anbncn: n ≥ 0}, and f((G)) would
have to be a CFG for this language, which we have proved not to exist.
A somewhat cuter answer is that with a Turing computable
CFG-complementer and a decider for ECFG (which does
exist), we could easily build a decider for ALLCFG. But
ALLCFG is proven to not be TD in Sipser.
It does exist, though no one proved this on the exam. We observed in
lecture (following Sipser's proof that ALBA is TD) that
given an LBA M with q states, a tape alphabet Γ of size k, and
an input w of length n, there are only qnkn possible
configurations of M. If M runs longer than this many steps,
therefore, it will never accept. Clearly an ordinary TM can simulate
M for that many steps on input w, rejecting w if M accepts and
otherwise accepting w. But we need to show that an LBA can
carry out this simulation. To do this, our simulating LBA N needs to
simultaneously use its tape to simulate M on w and to maintain a
counter that can go higher than qnkn. This is possible if
N has a much larger tape alphabet, say size (q + k)(k + 1). For
sufficiently large n, (k + 1)n is larger than
qnkn. We interpret the tape of N as coding the
configuration of M
(using extra letters to record the head position) and a sequence of n
"digits" in base k + 1. To simulate one step of M, N does the
appropriate steps at the head position, then goes to the right of its
tape and increments the counter, taking care of carries as necessary.
If the counter gets back to all zeros before the simulated M accepts,
then N accepts.
The LBA-complementer must take any LBA M and produce a desciption
of the corresponding N.
The machine must never print a blank and move right, or print a non-blank and move left. Otherwise it obeys the rules, even if it stays put. Before its move, it has a non-blank to the left and a blank to the right. So if it stays put, it is still following the rule whatever it prints. If it prints a blank and moves left, it is on the left-most non-blank. And if it prints a non-black and moves right, it is on the leftmost blank.
Each tape of an RETM operates like a stack, since changes to its
content can occur only at the right end. A move left (after printing
a blank) corresponds to a pop, and a move right (after printing
a non-blank) corresponds to a push.
A PDA can thus be built to simulate an arbitrary one-tape
RETM, though there are a couple of complications. The PDA must
begin by reading its input an putting it on the stack, whereupon
it is now written backward. It can then simulate the rest of
the computation of the RETM. The language of the PDA is thus
the reversal of the language of the language of the
RETM. The language of the PDA is decidable, and so the language
of the RETM is decidable as well.
As on HW#3, we can simulate an arbitrary one-tape TM using a machine with two stacks, passing characters from one stack to the other as the head goes past them. Given M, an arbitrary one-tape TM, we can create M', a two-tape RETM with L(M') = L(M), using the simulation of a stack by the tape of an RETM. The function taking (M) to (M') reduces ATM to ARETM, proving that the latter language is not TD.
Last modified 4 April 2012