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 (Sec 3)

Which of the following is true?

1. If `L` is a language containing strings of length less than five, then a deterministic finite automata for this language would only read at most six symbols from an input before halting.
2. If `L` is a regular language, then so is `L' = {0w | w in L}`.
3. Let `q_0` be the start state of the deterministic finite automata `M`. Then it is possible that `delta^\star(q_0, w) = q !in F`, the set of final states, yet `M` accepts `w`.

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_0, F)` we want to simulate how it acts on a string `w` with a DFA, `M= (Q', Sigma, delta', q_0', 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 power set of `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 the new start state be `q_0'=E(q_0)`. 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
• Notice what JFLAP gives you actually is still an NFA. What's missing in the above is a transition from the state {q_2} to a trap state {} on either a 0 or a 1.