Review:

1

• 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.

2

• 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(S2x) 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.

3

• 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
• DtranT, a U
• end
• end
• Initial state e-closure(s0), Final state ?

4

• 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!!

5

• 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.

6

• 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).

7

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