Review: NFA Definition NFA is non-deterministic in what sense? Time complexity of the algorithm to determine whether a string can be recognized by an NFA. Algorithm to convert a regular expression to an NFA.

The algorithm that recognizes the language accepted by NFA(revisit). Input: an NFA (transition table) and a string x (terminated by eof). output “yes” if accepted, “no” otherwise. S = e-closure({s0}); a = nextchar; while a != eof do begin S = e-closure(move(S, a)); a := next char; end if (intersect (S, F) != empty) then return “yes” else return “no” Time complexity O(|S|^2|x|) : With transition e-closure is a set, move({s}, a) may also be a set. Converting a NFA to a DFA that recognizes the same language: starting from and assign each set to a new state. Example: Figure 3.27 in page 120.

Algorithm to convert an NFA to a DFA that accepts the same language (algorithm 3.2, page 118) initially e-closure(s0) is the only state in Dstates and it is marked while there is an unmarked state T in Dstates do begin mark T; for each input symbol a do begin U := e-closure(move(T, a)); if (U is not in Dstates) then add U as an unmarked state to Dstates; Dtran[T, a] := U; end end; Initial state = e-closure(s0), Final state = ?

Question: for a NFA with |S| states, at most how many states can its corresponding DFA have? Using DFA or NFA?? Trade-off between space and time!!

The number of states determines the space complexity. A DFA can potentially have a large number of states. Converting an NFA to a DFA may not result in the minimum-state DFA. In the final product, we would like to construct a DFA with the minimum number of states (while still recognizing the same language). Basic idea: assuming all states have a transition on every input symbol (what if this is not the case??), find all groups of states that can be distinguished by some input strings. An input string w distinguishes two states s and t, if starting from s and feeding w, we end up in a non-accepting state while starting from t and feeding w, we end up in an accepting state, or vice versa.

Algorithm (3.6, page 142): Input: a DFA M output: a minimum state DFA M’ If some states in M ignore some inputs, add transitions to a “dead” state. Let P = {All accepting states, All nonaccepting states} Let P’ = {} Loop: for each group G in P do Partition G into subgroups so that s and t (in G) belong to the same subgroup if and only if each input a moves s and t to the same state of the same group in P put the new subgroups in P’ if (P != P’) {P = P’; goto loop} Remove any dead states and unreachable states (transition between groups can be inferred).

Lex implementation: Example: minimize the DFA for Fig 3.29 (pages 121) Regular expression  NFA  DFA  optimized DFA How to deal with multiple regular expressions?