1 / 7

Review: NFA Definition NFA is non-deterministic in what sense?

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

gerik
Download Presentation

Review: NFA Definition NFA is non-deterministic in what sense?

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

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

  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; Dtran[T, 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?

More Related