1 / 23

Nondeterministic Finite Automata

Nondeterministic Finite Automata. CS 130: Theory of Computation HMU textbook, Chapter 2 (Sec 2.3 & 2.5). NFAs: Nondeterministic Finite Automata. Same as a DFA, except:

gparrish
Download Presentation

Nondeterministic Finite Automata

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. Nondeterministic Finite Automata CS 130: Theory of Computation HMU textbook, Chapter 2(Sec 2.3 & 2.5)

  2. NFAs:Nondeterministic Finite Automata • Same as a DFA, except: • On input a, state q may have more than one transition out, implying the possibility of multiple choices when processing an input symbol • On input a, state q may have no transition out, implying the possibility of “being stuck” • A string w is acceptable as long as there exists an admissible state sequence for w

  3. NFAs • A nondeterministic finite automaton M is a five-tuple M = (Q, , , q0, F), where: • Q is a finite set of states of M •  is the finite input alphabet of M • : Q    power set of Q, is the state transition function mapping a state-symbol pair to a subset of Q • q0 is the start state of M • F  Q is the set of accepting states or final states of M

  4. Example NFA • NFA that recognizes the language of strings that end in 01 0,1 Exercise:draw the complete transition table for this NFA 1 q2 0 q1 q0 note: (q0,0) = {q0,q1} (q1,0) = {}

  5. ^ definition for an NFA • ^: Q X *  power set of Q • ^(q, ) = {q} • ^(q, w), w = xa(where x is a string and a is a symbol)is defined as follows: • Let ^(q, x) = {p1,p2,…pk} • Then, ^(q, w) =  (pi, a)

  6. Language recognized by an NFA • A string w is accepted by an NFA M if^(q0, w)  F is non-empty • Note that ^(q0, w) represents a subset of states since the automaton is nondeterministic • Equivalent definition: there exists an admissible state sequence for w in M • The language L(M) recognized by an NFA is the set of strings accepted by M • L(M) ={ w | ^(q0, w)  F is non-empty }

  7. Converting NFAs to DFAs • Given a NFA, M = (Q, , , q0, F), build a DFA, M’ = (Q’, , ’, {q0}, F’) as follows. • Q’ contains all subsets S of states in Q. • The initial state of M’ is the set containing q0 • F’ is the set of all subsets of Q that contain at least one element in F (equivalently, the subset contains at least one final state)

  8. Converting NFAs to DFAs • ’ is determined by putting together, for each state in the subset and each symbol, all states that may result from a transition:’(S, a) =  (q, a)qS • May remove “unreachable” states in Q’

  9. Example conversion • NFA • DFA 0,1 1 q2 0 q1 q0 1 0 1 0 {q0,q1} {q0,q2} {q0 } 0 1

  10. NFA with -transitions • NFA that allows the transition of an empty string from a state • Jumping to a state is possible even without input • Revision on NFA definition simply allows the  “symbol” for 

  11. NFA with -transitions • A nondeterministic finite automaton with -transitions (or -NFA) is a five-tupleM = (Q, , , q0, F), where: • Q is a finite set of states of M •  is the finite input alphabet of M • : Q  ( + )  power set of Q, is the state transition function mapping a state-symbol pair to a subset of Q • q0 is the start state of M • F  Q is the set of accepting states or final states of M

  12. Converting -NFAs to NFAs • Task: Given an -NFA M = (Q, , , q0, F),build a NFA M’ = (Q, , ’, q0, F’) • Need to eliminate -transitions • Need epsilon closure concept • Add transitions to enable transitions previously allowed by the -transitions • Note: the conversion process in the textbook instead builds a DFA from an -NFA • The conversion described in these slides is simpler

  13. Epsilon closure • In an NFA M, let q  Q • ECLOSE(q) represents all states r that can be reached from q using only -transitions • Recursive definition for ECLOSE • If (q, ) is empty, ECLOSE(q) = {q} • Else, Let (q, ) = {r1, r2,…, rn}.ECLOSE(q) = ECLOSE(ri)  {q} • Note: check out constructive definition of ECLOSE in the textbook

  14. Additional transitions • NFA M’ = (Q, , ’, q0, F’) such that ’ is described as follows • Suppose ECLOSE(q) = {r1, r2,…, rn }. • For each transition from state ri tostate sj on (non-epsilon) symbol a,add a transition from qto sj on symbol a • (For each transition from state sj tostate qon (non-epsilon) symbol a,add a transition from sj to rj on symbol a, for each rj) • ’ =  minus the epsilon transitions plus the additional transitions mentioned above

  15. Final states • NFA M’ = (Q, , ’, q0, F’) such that F’ is described as follows • F’ = F plus all states q such that ECLOSE(q0) contains a state in F

  16. Equivalence of Finite Automata • Conversion processes betweenDFAs, NFAs, and -NFAs show that no additional expressive capacity (except convenience) is introduced by non-determinism or -transitions • All models represent regular languages • Note: possible exponential explosion of states when converting from NFA to DFA

  17. Closure of Regular Languages under certain operations • Union L1  L2 • Complementation L1 • Intersection L1  L2 • Concatenation L1L2 • Goal: ensure a FA can be produced from the FAs of the “operand” languages

  18. Union • Given that L1 and L2 are regular, then there exists FAs M1 = (Q1, 1, 1, q10, F1) andM2 = (Q2, 2, 2, q20, F2) that recognizeL1 and L2 respectively • Let L3 = L1  L2. Define M3 as follows:M3 = ({q30}Q1Q2,12, 3, q30,F1F2) • where 3 is just 12 plus the following epsilon transitions: q30  q10 and q30  q20 • M3 recognizes L3

  19. Complementation • Given that L1 is regular, then there exists DFA M1 = (Q, , , q0, F) that recognizes L1 • Define M2 as follows:M2 = (Q, , , q0, Q - F) • M2 recognizes L1 • Strings that used to be accepted are not, strings not accepted are now accepted • Note: it is important that M1 is a DFA; starting with an NFA poses problems. Why?

  20. Intersection • By De Morgan’s Law,L1  L2 = ( L1L2 ) • Applications of the constructions provided for and complementation provide a construction for 

  21. Concatenation • Given that L1 and L2 are regular, then there exists FAs M1 = (Q1, 1, 1, q10, F1) andM2 = (Q2, 2, 2, q20, F2) that recognizeL1 and L2 respectively • Let L3 = L1L2. Define M3 as follows:M3 = (Q1Q2, 12, 3, q10, F2) • where 3 is just 12 plus the following epsilon transitions: q1i  q20 for all q1i in F1 • M3 recognizes L3

  22. Finite Automata with Output • Moore Machines • Output symbol for each state encountered • Mealy Machines • Output symbol for each transition encountered • Exercise: formally define Moore and Mealy machines

  23. Next: Regular Expressions • Defines languages in terms of symbols and operations • Example • (01)* +(10)* defines all even-length strings of alternating 0s and 1s • Regular expressions also model regular languages and we will demonstrate equivalence with finite automata

More Related