Outline

• Product Construction
• Quiz
• Nondeterministic Finite Automata
• NFAs and DFAs recognize the same class of languages

Product Construction

Theorem

If `A_1` and `A_2` are two regular languages, so is their union `A_1 cup A_2`.

Proof. Let `M_1=(Q_1, Sigma, delta_1, q_1, F_1)` and `M_2 =(Q_2, Sigma, delta_2, q_2, F_2)` be the DFAs recognizing languages `A_1` and `A_2`. We would like to make a new DFA, `M`, which simultaneously simulates both `M_1` and `M_2` and accepts a string `w` if either of `M_1` and `M_2` accepts. To simulate both machines at the same time we use a so-called "cartesian product construction". To do this let `Q = Q_1 times Q_2`. `M`'s alphabet is `Sigma` like that of `M_1` and `M_2`. Define `delta((q, q'), a) = (delta_1(q,a), delta_2(q',a))`. Let the start state of `M` be `(q_1, q_2)`. Finally, let `F = (F_1 times Q_2 )cup (Q_1 times F_2 )`. Verify at home that `M` has the desired properties.

Example

• Let `L = {w | w=101v \ mbox{where} \ v in {0, 1}^star }` and let `L' = {w | w=01v' \ mbox{where} \ v' in {0, 1}^star }`
• Then a DFA for `L` might look like:
  
• And one for `L'` might look like:
  
• Doing the product construction by hand can be super painful. Humans and non-brain dead algorithms, might create the product of the states but then only draw the edges that are reachable from the start node. We gave an algorithm for reachability a couple days back.
• The reachable portion of the product graph (all states drawn, but only reachable edges listed) for the above two automata might look like:
  

Quiz

Which of the following is true?

1. It is possible for a DFA to transition from some other state into a trap state.
2. The transition function for a deterministic finite automata can be not a total function.
3. The class of languages accepted by DFAs are not closed under concatenation.

Nondeterministic Finite Automata

• Having trap states, and transitions in general for every alphabet symbol can make ones diagrams looks messy and be a pain to maintain.
• To get around this one could imagine using a rule which says a string is automatically rejected if it ever happens that one cannot transition out of a state by reading the next symbol of the string.
• It is also sometimes convenient if we want to build bigger automata out of smaller automata, to allow two transitions with the same alphabet symbol out of a state. Or even to allow transitions where we don't read a symbol at all!
• These ideas motivate the concept of nondeterministic machine.

Example NFA

• Notice we have more than one transition out of a state, we can have `epsilon`-transitions, and we don't need to have a transition from every alphabet symbol from a state.
• We say the NFA accepts `w` roughly if there is some sequence of transitions beginning with the start state, that processes each character of w, and ends in an accept state.
• For instance, the machine above accept `\epsilon`, `0`, `00`, `000`, `1`; but rejects `01`, `11`, `0001`. It rejects `01` because although it can get to state `q_2` after seeing `epsilon 0 = 0`, it has nowhere to go when it sees a `1` so it can't process the `1` so it rejects. No other path in the machine processes `01` even this far.

Formal Definition of an NFA

• Recall the power set of a set `Q`, `P(Q)`, is the set of all subsets of `Q`.
• A nondeterministic finite automaton is a 5-tuple `(Q, Sigma, delta, q_0, F)` where:
  1. `Q` is a finite set of states
  2. `Sigma` is an alphabet
  3. `delta: Q times Sigma cup {epsilon} rightarrow P(Q)` is the transition function
  4. `q_0 in Q` is the start state
  5. `F subseteq Q` is the set of accept states.
• NFAs were proposed in a paper of Rabin and Scott in 1959. (IBM J. Research and Development. Vol. 3 Iss. 2)

Example

• The machine a couple slides back is defined as `(Q, Sigma, delta, q_1, F)` where:
  1. `Q={q_1, q_2, q_3}`
  2. `Sigma={0,1}`
  3. `delta` is given by:
     `delta(q_1, epsilon)rightarrow {q_2} quad delta(q_1, 0)rightarrow {} quad delta(q_1, 1) rightarrow {q_2,q_3}`
     `delta(q_2, epsilon)rightarrow {} quad delta(q_2, 0)rightarrow {q_2} quad delta(q_2, 1)rightarrow {}`
     `delta(q_3, epsilon)rightarrow {} quad delta(q_3, 0)rightarrow {} quad delta(q_3, 1)rightarrow {}`
  4. `q_1` is the start state
  5. `F = {q_2, q_3}`

Formal Definition of Accepts

• To define what it means for an NFA to accept we can modify the definition of `delta^star` so that it works on a set of states. i.e., `delta^star(q_i, w) =Q_j`, where `Q_j` is the set of possible states one could be in after processing `w` starting in state `q_i`.
• We say `M` accepts `w` then if `delta^star(q_0, w) cap F` is nonempty.
• We write `L(M)` for the set of strings `M` accepts.

Equivalence of NFAs and DFAs -- The Power Set Construction

Theorem Any language recognized by an NFA is recognized by some DFA.

Proof: Given an NFA `N= (Q, Sigma, delta, q, F)` we want to simulate how it acts on a string `w` with a DFA, `M= (Q', Sigma, delta', q', F')`. The idea is we want to keep track of what possible states it could be in after reading the first `m` characters of `w`. Let `Q'= P(Q)`. The alphabet is the same. For each `R in Q'` (i.e., `R subseteq Q`) and `a in Sigma`, let `delta'(R, a) = {q in Q | q in E(delta(r,a)) \ mbox{for some} \ r in R}`. Here `E(q')` is the set of states reachable from `q'` following 0 or more `epsilon` transitions, for a set of states `Q''`, `E(Q'')` is the union of `E(q'')` for `q'' in Q''`. Let `q'=E(q)`. Let `F' = {R in Q'| R \ mbox{contains an accept state of} \ N}`.

This construction is from the original NFA paper of Rabin and Scott (1959).

Example Conversion

• Here is an initial NFA:
  
• Here is the result of the conversion, where unreachable states have been removed:
  
• JFLAP let's you step through the conversion process
• The subscript beneath a state after the conversion corresponds to a set of states from the original NFA