CSE 355 Final Exam

Suppose that I have two DFAs and have 5 and 4 states respectively, and 2 and 3 final states respectively. The number of final states in the product DFA for the union of their languages is

17

What is the smallest number of states that a TM could have?

2 - since q_accept is not equal to q_reject, there must be at least two. Note there is nothing to prohibit q0 from being either state

What is the smallest number of tape symbols that a TM with nonempty input alphabet could have?

2 - since the input alphabet is nonempty, there is at least one. But since the blank symbol is in the tape alphabet but not the input alphabet, we can have 2 symbols.

Suppose that I have two DFAs and have 5 and 4 states respectively, and 2 and 3 final states respectively. The number of states in the product DFA for the intersection of their languages is

20

Suppose I have a CFG, and can guarentee that the longest right hand side of any rule in the gammer is at most 5 and there are n rules. I want to convert this to an equivalent PDA as described in class. Which of the following is the best upper bound on the number of states that will be in this PDA

5n + 5

Suppose that a Turing Machine is run on an input. Which of the following is false?

A configuration of the machine must have infinite length because the tape is infinite True answers: - Infinitely many configurations of the machine can occur - If a configuration of the machine arises twice in a computation on this input, the machine enters an infinite loop - every configuration contains exactly one state of the machine - configurations are used to define the language that the machine recognizes

The statement ANFA <= ADFA means

ANFA reduces to ADFA

Non-regular languages are closed under

Complement

Under what operations are recognizable languages NOT closed

Complement

My friend does not believe the fact that ATM is undecidable because he says that he can tell whether his program is in an infinite loop on a given input. Suppose that my friend has a specific program M and a specific input w. He defines the language L = {0} if M halts on input w and L = {1} if M goes into an infinite loop on input w. Then L is

Decidable because L is regular

Under what operations are decidable languages NOT closed

Decidable languages are closed under all of the following: a) Complement - swap q_accept and q_reject b) Union - run both machines and accept if either says accept, otherwise reject c) Intersection - similar to union d) Star - for all possible decomposition of the input, run all decomposition on the decider, and accept if at least one decomposition has all of its parts be accepted. Otherwise, reject

Consider the problem of determining, from a given PDA, whether the PDA has infinite language or not. Is this decidable? Why or why not?

Decidable: because of the pumping lemma for CFLs

Stacks have been getting very expensive lately! I want to limit the stack size of a PDA to be at most 25 to save cost; call the machines that have this property RPDAs. This model works exactly as a normal PDA does, but if the stack has height 25 and on the next transition does not pop and does push, the computation immediately stops. What is the relation between the class of languages PDAs recognize and those that RPDAs recognize?

Every language a RPDA recognizes a PDA recognizes, but not vice versa

In the conversion algorithm described in class, that coverts a CFG to a PDA with the same language, how many final states were in the resulting PDA?

Exactly 1

Call a PDA pop-friendly if it can only push but not pop on each transition. Then, every PDA can be converted into a pop-freindly PDA with the same language.

False

If a language is not context-free, then every subset of it is also not context free

False - Any non-context-free language is a counterexample (in fact, this is always false)

The language {a^i b^j c^k : 0 <= i <= j <= k} is context free

False - Choose 0^p 1^p 2^p and pump accordingly. Pump down if either v or y contains a 2. But in all other cases, we can pump up to get out of the language

Every decidable language is a CFL

False - Many counterexamples, including {0^n 1^n 2^n : n >= 0}

Suppose a PDA pops, but doesn't push on every transition. Then the language of the PDA is context-free, but not necessarily regular.

False - The PDA can never execute a transition. Therefore, its language is either empty set or empty string and it is regular in both cases

Suppose a PDA pushes, but doesn't pop on every transition. Then the language of the PDA is context-free but not necessarily regular

False - The PDA might as well ignore its stack since it cannot inspect the stack. Therefore its language is always regular since it behaves like an NFA.

The language {w ∈ {a, b}* : the number of occurrences of ab in w is the same as that of ba in w} is not regular

False - This language is another way of asking that w starts and ends with the same character, or is epsilon, and one can make a DFA for that

PDAs always end computation with an empty stack

False - by definition

If a language is context-free, then every subset of it is also context-free

False - sigma star is a counter example

The number of states in PDA can be 0

False - since q0 is in Q, Q cannot be empty

Every language that a Turing Machine can recognize is a CFL

False - we made TM for 0^n 1^n 2^n : n >= 0 in class

SUBPDA = {<M1, M2> | M1 and M2 are PDAs and L(M1) is a subset of L(M2)} is decidable

False -ALLCFG (and hence ALLPDA) is undecidable. We make a decider for ALLPDA using supposed decider D for SUBPDA as follows: on input a PDA M, first construct a PDA P that accepts sigma star, and feed <P,M> to D. The answer that D gives is what the decider for ALLPDA would say.

There is a language that is decidable and its complement is not decidable

False -Decidable languages have closure under complement

The problem of whether a given TM has at least 355 string in its language or not is decidable

False -Rice's Theorem

Rice's theorem states that many languages are not recognizable

False -Should be "not decidable"

A Turing Machine can have a choice as to whether to move right or left on a given transition

False -TMs are deterministic

There is an enumerator that has a language that is not recognizable

False -We showed in class that enumerable and recognizable languages are equivalent

The problem of determining whether a TM has at least 7 states is undecidable

False -this is decidable

My friend believes that we can convert a DFA except for every transition labelled a in the DFA, we augment the transition to be a, eps -> eps between the same pair of states. Is his idea correct?

His idea is correct because DFAs are just PDAs that ignore the stack

In the conversion of a PDA with n states to a CFG, the number of rules created (without doing any simplifications) is

Impossible to classify without more info

Let L be a regular language. How many DFAs have language L?

Infinitely Many

Randomness is very useful, but normal TMs don't have this property. So, let a Random Turing Machine (RTM) be a machine model like a normal TM where each transition has a certain probability of being executed. For a given state, and given tape symbol, there may be several possible transitions that can be executed; but the sum of their probabilities is always 1, and only one of those transitions is executed (and the transition is picked randomly based on the probabilities of the transitions). For example, we could have two transitions from the same state on the same tape symbol read, one with probability 0.7 and the other with 0.3; the first will be executed with 70% probability, and the other with 30%. Of course, if we feed the input to the machine several times, the answer of whether it accepts or not may change each time. We say that a string is accepted by an RTM if there is at least one computation that accepts that string, and the language being the set of all strings that are accepted by the RTM. How do the languages that RTMs recognize compare to that of the standard model?

It is equivalent because we can create a TM for all possible choices of each transition being present or absent, and run all machines simultaneously (and we accept if and only if at least one of the machines accepts)

I have a Turing Machine variant called the End Jumper - the model is exactly the same as a normal TM, except that a special instruction (in addition to L and R) that moves the tape head, in a single transition, to the cell directly after the last non-blank cell on the tape. How does this variant compare to usual Turing Machines.

It is equivalent because we can mark the furthest right non-blank cell on the tape and maintain it through the course of computation

My friend is interested in computations of machines, and wants to see if he can find a "repeating" pattern during such a computation. Formally, observe the language {#w1#w2#....#wk# : wi = {0, 1}*, and for some i not equal to j, wi = wj} My friend believes this language is context-free. Is it?

It is not context free because #0^p 1^p # 0^p 1^p # pumps out of the language

Which of the following statements is correct about the language {0^i 1^(i+j) 2^j : i, j ≥ 0}?

It is not regular, but it is context free

My Turing Machine is broken (again)! It is never allowed to move past the end of where the input is! this of it as a tape that has two ends, instead of one (as is in the standard model). Consider all TMs that have this property. What languages do they recognize

It's not exactly the CFLs because {0^n 1^n 2^n : n ≥ 0} is recognized by a TM in this model. We get all of the CFLs as well (CFG in CNF?). However, we do not get all of the decidable languages. Define the language A = {<B> | B is a TM in this model and <B> is not in L(B)} Suppose A were decided by a machine M in this model. If <M> ∈ L(M), then <M> ∈ A, proving that <M> is not in L(M). If <M> is not in L(M), then <M> is not in A, proving that <M> ∈ L(M). Since a contradiction is reached, A is not decided by any TM in this model. This may seem like a contradiction for normal TMs. However, we can decide A as follows: if the tape head ever moves past the end of where the input is, reject. Suppose there are q states, k tape symbols, and the input was of length n. The total number of configurations is kqk^n. If on the (kqk^n + 1)-th transition the machine has not accepted or rejected yet, it has repeated a configuration, and hence is in an infinite loop. Therefore, we can decide the acceptance problem for this model.

The set of non-context free languages is closed under which of the following

NONE (none of complement, union, intersection, or concat)

Suppose I have a CFG (not necessarily in CNF) and a string of length 5 in its language. What can I tell about a derivation of this string in the grammar?

Nothing, the derivations can be arbitrarily large or even infinite

In the conversion of a PDA with n states to a CFG, the number of variables created (without doing any simplifications) is

O(n^2) but not a constant independent of n - we always make exactly n^2 states

In a DPDA, suppose we allow only transitions that can do only one of pop, push, and read. To break up a transition that does all three we should

Read then pop then push

Consider the CFG used in the proof of the pumping lemma. We chose a string long enough so that it is accepted by the CFG and repeats a variable. What if such a string does not exist for this CFG?

The CFG's language must be infinite

Consider the DFA used in the proof of the pumping lemma: we chose a string long enough so that it is accepted by the DFA and repeats a state. What if such a string happens to does not exist for this DFA?

The DFA's language must be finite

Suppose I have a CFG in CNF and a string of length 5 in its language. What can I tell about a derivation of this string in the grammar?

The derivation involves exactly 9 applications - 2n - 1 derivations in CNF

The pumping lemma for CFLs writes a long enough string in the language in five parts uvxyz and requires that |vy| >= 1. This requirement can be enforced because in the proof of the pumping lemma

The grammar has no epsilon-rules except perhaps from the start variable

Anaconda corporation has announced a new product that, when given a Python program P has input, can determine whether P can go into an infinite loop on any input. Which of the following is true?

Their product does not work because Turing Machines can be converted to Python programs

For some reason, my friend doesn't like odd numbers. Suppose he wants every accepting computation of every string to consist of an even number of transitions; call machines that have this property EPDAs. If a computation enters an accept state and has read all of the input, the machine may still not accept because there possibly have been an odd number of transitions applied. What is the relation between the class of languages PDAs recognize and those that EPDAs recognize?

They are exactly the same

Transitions that read a character off the input are very tiresome, so we want to allow "breaks" between them. I want every accepting computation of every string to consist of at least 1 epsilon-transition between each character read from the input (I'm not worried about what happens on the stack here). Call these machines HPDAs. What is the relation between the class of languages PDAs recognize and those that HPDAs recognize?

They are exactly the same

Call a PDA strict if it can do exactly one of its push or pop operations on each transition. Then, every PDA can be converted into a strict PDA with the same language.

True

Call a regular expression star-free if it does not contain any occurrences of the * operation. If R is a star-free regular expression, then L(R) is finite

True

Context-free languages are closed under intersection with regular languages

True

FINITEDFA = {<M> | M is a DFA with finite language} is decidable

True

The language {w ∈ {a, b}* : the number of occurrences of a in w is the same as that of b in w} is not regular

True

The language {ww : w ∈ Σ*} with |Σ| ≥ 2 is not regular

True

The question "Does a given DFA accept a given input" is decidable

True - ADFA

Suppose I want to convert a regular grammar into CNF. Because we start with a regular grammar, one of the 5 steps of the CNF algorithm can be skipped

True - It turns out we can skip Step 5 (breaking up long RHSes) since the longest rule in a regular grammar has at most two variables/terminals on the RHS.

The language {a^i b^j : 0 <= i <= j <= 2i } is context free

True - One can make a CFG for it by appending the rule S -> aaSb to the grammar for {a^n b^n : n >= 0}. This ensures that the number of bs is at least the number of a's but at most twice.

Suppose I have an algorithm to test if a given CFG accepts some input. Therefore, I have an algorithm to test if a given PDA accepts some input

True - PDAs can be converted to CFGs

If L is not context-free, F is a finite language with empty intersection with L and L' = L U F, then L' is also not context free

True - Suppose L' were context-free. Then we can rewrite the statement as L = L = L'\F, only on the assumption that L, F have empty intersection. Now, since F is finite, it is regular. So L'\F = L intersect (complement of F) is context free. But L is not context free.

Every decidable language is recognizable

True - by definition

In the formal definition of a PDA, we cannot swap the order of push and pop in the transition function. We must allow popping before pushing

True - by definition

PDAs always start computation with an empty stack

True - by definition

Suppose a PDA pushes or pops but doesn't do both or neither, on every transition. Then the language of the PDA is context-free but not necessarily regular

True - like a step-conversion from a PDA to a CFG, so it is true

Suppose we augmented our definition of a TM to include moving right 5 tape cells in a single transition. Then the class of languages ordinary TMs recognize is the same as this augmented mondel

True - to simulate a "5-right" transition, just add 5 consecutive transitions that move right

Every CFL is decidable

True - we can convert to a CFG in CNF, and use the algorithm outlined in class

Every regular language is decidable

True - we can simulate a DFA using a TM

There is a language that is recognizable and its complement is not recognizable

True -ATM is an example

Every TM's starting configuration is unique

True -By referring to a "configuration" by definition this refers to some input string w. Since TM's starting state is defined, and the input string is defined, there is exactly 1 starting configuration.

The problem of determining whether a TM accepts at least 7 strings is undecidable

True -Rice's theorem

Every CFL can be recognized by a Turing Machine

True -Convert the CFG for the language into CNF -try all 2n-1 derivations of the input string -If any are the input string itself, accept

There is a recognizer that has an undecidable language

True (ATM)

My friend is curious about the language L = {<M> : M is a TM and accepts 3 strings}. Is this language decidable? Why or why not?

Undecidable: We can construct a decider for ATM assuming a decider for this language - this can be done using Rice's Theorem

The pumping lemma for CFLs writes a long enough string in the language in five parts uvxyz and requires that |vxy| <= p. This requirement can be enforced because in the proof of the pumping lemma

We chose a repeated variable on a longest root to leaf path that is furthest from the root

For a given TM and input, consider the language of accepting computation histories of that TM on that input. Then this language is a) Decidable because in all cases this language is finite b) Decidable because we can simulate the TM until it halts c) Undecidable because it we can find out if this language is empty or not, we can solve the acceptance problem for TMs d) Undecidable because determining computation histories is undecidable, so accepting computation histories is also undecidable e) None of the above

a) Decidable because in all cases this language is finite

The acceptance problem for LBAs is a) Decidable because we can detect an infinite loop in a finite amount of time b) Decidable because there cannot actually be an infinite loop in an LBA c) Undecidable because this is just the acceptance problem for TMs but for a restricted class of them d) Undecidable because we can reduce from the emptiness problem for LBAs which is undecidable e) None of the above

a) Decidable because we can detect an infinite loop in a finite amount of time

My Turing Machine is broken! It can only move left, at lost, 5 times in the course of computation on any input! Consider all TMs that have this property. What languages do they recognize?

a) Exactly the regular languages - There are finitely many possibilities of what can happen here (in terms of moving left), so we model each as a state with transitions according to what character was read moving left

I want to prove that the language {w ∈ {a, b}* : w is a palindrome} is not regular. Which is a good string to pick?

a^p b b a^p

On input string w ∈ Σ*, the number of computations of an NFA (Q, Σ, δ, q0, F) is always

at least 1 if the NFA accepts w

The problem of deciding whether a given TM accepts some string of length 5 is a) Undecidable because if a decider existed, then one can decide whether or not a DFA has an empty language b) Undecidable because of Rice's Theorem c) Decidable because we can just test all strings of length 5 simultaneously and see if any accept d) Decidable because we can decide it using a decider for the acceptance problem for LBAs e) None of the above is true

b) Undecidable because of Rice's Theorem

My friend wants to apply Rice's theorem to the language {<M> : M accepts epsilon and has at least 5 states}. I note that he cannot apply Rice's theorem for this language. What is the reason why he cannot?

b) because this language is not a property of the language of TMs

A generalized NFA, or GNFA

can have transitions labelled with ∅ or ∅*

(empty set)* = empty set

false - (empty set)* = empty string (epsilon)

If DFA M = (Q, Σ, δ, q0, F) accepts the input string w on Σ* with |w| = n, a computation of M on w

is a sequence of exactly n + 1 states

My friend still does not understand Chomsky Normal Form (indeed he insists on calling it Chompsky Normal Form). He thinks that every rule that has two symbols on the RHS must have exactly one variable and one terminal rather than just two variables (otherwise he has the definition right). His version is not suitable because:

it generates all regular languages and some others, but not all CFLs

If NFA M = (Q, Σ, δ, q0, F) accepts the input string w on Σ* with |w| = n, a computation of M on w

may be a sequence of any integer number of states that is at least n + 1

{a^n b^m : n > m ≥ 0} is

not regular because a^(p+1)b^p cannot be pumped

The pumping lemma for regular languages can be proved by

showing that a DFA computation must repeat a state.

Regular operations

star, union, concat

For an NFA M = (Q, Σ, δ, q0, F) and a subset S ⊆ Q, which of the following is not always true about the ε closure E(S)?

there is no ε transition from a state not in E(S) to a state in E(S)

Every non-regular language is infinite

true

If a DPDA has the transition δ(q, a, x) = (q', y) with a ∈ Σ, x ∈ Γ, then it can also have the transition:

δ(q, epsilon , y) = (q', x) provided x != y and y ∈ Γ