1.

2 substrings

2. L*:abaabaaabaa, aaaabaaaa, baaaaabaa

L4: baaaaabaa, baaaaabaa

3.

A,
B
4 A,
B

B
A A 3
1 2

4.

A A
8
1 A 2 B 3 B 4 B 5 B 6 B 7 B
A A A A
A
B A
9
5.

A 1
0 B
B A
B
A 2
6.

Σ=
{A} A
q
q A
M 1
0 L(M) = {A*} L(M)’ = {λ}
q A
A q
M 1 L(M’) = {λ}
0
’
In the two DFA’s presented we have M and the inverse of M. L(M)’ is the complement set of all
strings accepted by L(M). While L(M’) is the set of all strings accepted by the inverse of the M
automata. Here I pictured a simple basic DFA that has an alphabet of A. M accepts all entries
with A inside them while M’ accepts all entries without A. By finding L(M) = {A,AA,AAA,...}
the complement set is an empty string. When we find L(M’) = {λ} we can then say that L(M)’ is
equal to L(M’)

7.

8.

A A A,B

B B 3 A,B
1 2 4

9.
δ* (q0, 1011) => q2
δ*(q1, 01) => hangs on q2

10.
 A
4
B
1 A 2
B
5 A 6
B
11.

B A

1 A 2

12.

B
1 A 2 A
4 A,B
B
B
3
A

13. This is possible because NFA are allowed to have empty string transitions. So if we create a
new state and connect all the final states to this new state. We can then turn all the final states
into regular states and this new state into the solo final state in the NFA. However this isn’t
possible with DFA’s because DFA’s require input for traversal and do not accept lambda
transitions so this would not be possible with a DFA.

14. Given that L is a regular language and LR is every string in L reversed. We can determine
that there is some finite automaton that accepts all strings in L. Because every NFA can be
modified to have one final state as proved in question 13. If we preform this transformation all
that would be left to do is reverse all the transition directions in the NFA, this would result in an
NFA that accepts the reverse of L or LR.

15. Given that L is a regular language and chopleft(L) is made by removing the leftmost symbol
for all strings in L. We can do this by replacing all transitions from the initial state and replacing
the transition value to lambda so that it won’t consume an input. This will remove the leftmost
symbol and result in a finite automaton that accepts all strings in L without the leftmost symbol.
Therefore chopLeft(L) is also regular.

16.

2 1 3
0
1 1 1,0

4
1,0