Name:

1 10
2 a 5
b 10 CS 341
3 10 First Midterm Exam
4 a 15 Practice
b 15
c 15
1. Use extra paper to determine your solutions then neatly transcribe
d 15
them (including intermediate steps) onto these sheets.
5 a 5
2. Its possible that you wont be able to finish. Read through the
b 15
whole exam once and start working on the problems youre sure you
c 15
know how to do. Come back to the harder ones as you have time.
6 15
7 15
8 a 5
b 5
c 5
Total 175

(1) Consider the following problem: Given a database D and a query Q, what result is returned
when Q is executed against D?

L = {<D, Q, R> : R is the result of executing Q against D}.

(2) Let L = {w {a, b}* : w does not end in ab}

(a) Show a regular expression that generates L.

b (a b)* (a bb)

(b) Show an FSM that accepts L.

b

1
b
a 2
b
3 a

a
(3) Show a (possibly nondeterministic) FSM that accepts {w {a, b}* : w contains at least one
instance of aaba, bbb or ababa}.

a b a a, b

a, b a

b b b a, b

b a b a
(4) For each of the following languages L, state whether it is regular or not and prove your answer.
(a) {x#y: x, y {0, 1}*, when viewed as binary numbers, x+y = 3y}. Example: 1000#100 L.

Not regular, which we show using the Pumping Theorem. We must start by choosing a string that is in fact in
L. Let w = 100k#10k. Then w L since x (100k) is equal to 2y (where y is 10k). We must consider three
cases for where y can fall:
y = 1 Pump out. Arithmetic is wrong. The left side is 0 but right side isn't.
y = 10* Pump out. Arithmetic is wrong. "
p
y = 0 Pump out. Arithmetic is wrong. Decreased left side but not right. So, in particular, it is no longer the
case that x > y (required since y 0).

(b) Let = {a, b}. L = {w *: (w contains the substring ab) (w contains the substring ba)}

Regular. It helps to rewrite L as:

L = {w *: (w contains the substring ab) (w contains the substring ba)}
L= b*a* (a b)* ba (a b)*

You can also do this with an FSM.

(c) {w = xyzy : x, y, z {0, 1}+}.

Regular. The key to why this is so is to observe that we can let y be just a single character. Then the rest of w
can generated by x and z. So any string w in {0, 1}+ is in L iff:
the last letter of w occurs in at least one other place in the string,
that place is not the next to the last character,
nor is it the first character, and
w contains least 4 letters.

Either the last character is 0 or 1. So:

L = ((0 1)+ 0 (0 1)+ 0) ((0 1)+ 1 (0 1)+ 1).

(d){w = st : s {a, b}* and t {b, c}* and #b(s) = 2#a(s) and #c(t) = 3#b(t)}.

Not regular, which we show by pumping. Let w = b2kakc3kbk. y must occur in the first b region. It is bp, for
some nonzero p. Note that, when we pump, the boundary between the s and t regions cannot move because
there can be no as in s or cs in t. Let q = 0 (i.e., pump out). The resulting string is b2k-pakc3kbk. The s region
is b2k-pak. It doesnt have twice as many bs as as. So this string is not in L.
(5) Recall that maxstring(L) = {w: w L and z* (z wz L)}.
(a) What is maxstring(L1L2), where L1 = {w {a, b}* : contains exactly one a} and L2 = {a}?

L1L2

(b) Prove that the regular languages are closed under maxstring.

The proof is by construction. If L is regular, then it is accepted by some DFSA M = (K, , , s, A). We
construct a new DFSM M* = (K*, *, *, s*, A*), such that L(M*) = maxstring(L). The idea is that M* will
operate exactly as M would have except that A* will include only states that are accepting states in M and from
which there exists no path of at least one character to any accepting state (back to itself or to any other). So an
algorithm to construct M* is:

1. Initially, let M* = M.
/* Check each accepting state in M to see whether there are paths from it to some accepting state.
2. For each state q in A do:
2.1. Follow all paths out of q for |K| steps or until the path reaches an element of A or some state
it has already visited.
2.2. If the path reached an element of A, then q is not an element of A*.
2.3. If the path ended without reaching an element of A, then q is an element of A*.

Comments on this algorithm:

1. Why do we need to start with a deterministic machine? Suppose L is ba*a. maxstring(L) = {}.
But suppose that M were:

q0 b q1 a q2

If we executed our algorithm with this machine, we would accept ba*a rather than {}.
2. Your initial thought may be that the accepting states of M* should be simply the accepting states
of M that have no transitions out of them. But there could be transitions that themselves lead no
where, in which case they dont affect the computation of maxstring. So we must start by finding
exactly those accepting states of M such that there is no continuation (other than ) that leads
again to an accepting state.

(c) If maxstring(L) is regular, must L also be regular? Prove your answer.

No. Consider Primea = {an : n is prime}. Primea is not regular. But maxstring(Primea) = , which is regular.
(6) Consider the following NDFSM M. Use ndfsmtodfsm to construct an equivalent DFSM. Begin
by showing the value of eps(q) for each state q:

1 ,a 2 b 3 b 4 a 5

a,b

eps(1) = {1, 2, 3}
eps(2) = {2, 3, 1}
eps(3) = {3}
eps(4) = {4}
eps(5) = {5}

{1, 2, 3}, a, {1, 2, 3}

, b, {1, 2, 3, 4}
{1, 2, 3, 4}, a, {1, 2, 3, 5}
, b, {1, 2, 3, 4}
{1, 2, 3, 5}, a, {1, 2, 3}
, b, {1, 2, 3, 4}

There is one accepting state, {1, 2, 3, 5}.

(7) Define a decision procedure to answer the following question. You may use as subroutines all
the procedures that we have discussed in class. Let = {a, b} and let and be regular
expressions. Is the following sentence true:

(L() = a*) (w (w {a, b}* |w| even) w L())

1. From , build FSM M1. Make it deterministic. Minimize it, producing M2.
2. Build Ma, the simple one-state machine that accepts a*.
3. If M2 and Ma are identical except for state names then return true. Else continue.

/* Observe that the second condition says that LE, the language of even length strings of as and bs, is a subset
of L(). This is equivalent to saying that LE - L() is empty. So:
4. From , build FSM M3.
5. Build ME that accepts exactly LE, the language of even length strings of as and bs.
6. Build MD that accepts L(ME) - L(M3).
7. See if L(MD) is empty. If it is, return True. Else return False.

(8) Prove or disprove each of the following statements:

(a) It is possible that the intersection of an infinite number of regular languages is not regular.

True. Let x1, x2, x3, be the sequence 0, 1, 4, 6, 8, 9, of nonprime, nonnegative integers. Let axi be a string
of xi as. Let Li be the language a* - {axi}.

Now consider L = the infinite intersection of the sequence of languages L1, L2, Note that L = {ap, where p is
prime}. We have proved that L is not regular.
(b) Every subset of a regular language is regular.
False.
Let L = a*, which is regular.
Let L' = ap, where p is prime. L' is not regular, but it is a subset of L.

(c) Let L4 = L1L2L3. If L1 and L2 are regular and L3 is not regular, it is possible that L4 is regular.

True. Example:
Let L1 = {}. L 1 is regular.
Let L 2 = a*. L 2 is regular.
Let L 3 = ap, where p is prime. L 3 is not regular.
L 4 = ak, where k 2 L 4 is regular, because it is defined by aaa*.