nondeterministic finite automata
Download
Skip this Video
Download Presentation
Nondeterministic Finite Automata

Loading in 2 Seconds...

play fullscreen
1 / 23

Nondeterministic Finite Automata - PowerPoint PPT Presentation


  • 121 Views
  • Uploaded on

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:

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Nondeterministic Finite Automata' - kaethe


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
nondeterministic finite automata

Nondeterministic Finite Automata

CS 130: Theory of Computation

HMU textbook, Chapter 2(Sec 2.3 & 2.5)

nfas nondeterministic finite automata
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
slide3
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
example nfa
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) = {}

definition for an nfa
^ 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)
language recognized by an nfa
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 }
converting nfas to dfas
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)
converting nfas to dfas1
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’
example conversion
Example conversion
  • NFA
  • DFA

0,1

1

q2

0

q1

q0

1

0

1

0

{q0,q1}

{q0,q2}

{q0 }

0

1

nfa with transitions
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 
nfa with transitions1
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
converting nfas to nfas
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
epsilon closure
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
additional transitions
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
final states
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
equivalence of finite automata
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
closure of regular languages under certain operations
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
union
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
complementation
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?
intersection
Intersection
  • By De Morgan’s Law,L1  L2 = ( L1L2 )
  • Applications of the constructions provided for and complementation provide a construction for 
concatenation
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
finite automata with output
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
next regular expressions
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
ad