Nondeterministic Finite Automata

CS 130: Theory of ComputationHMU textbook, Chapter 2

(Sec 2.3 & 2.5)

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

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 NFA that recognizes the language

of strings that end in 01

q0q2

0,1

0 1q1

note: (q0,0) = {q0,q1}(q1,0) = {}

Exercise:draw the complete transition table for this 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 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 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 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)qS

May remove “unreachable” states in Q’

Example conversion NFA

DFA

q0q2

0,1

0 1q1

{q0 }

1

0 1{q0,q1} {q0,q2}

0

0

1

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 -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 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 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 NFA M’ = (Q, , ’, q0, F’) such that ’ is described

as follows Suppose ECLOSE(q) = {r1, r2,…, rn }. For each transition from state ri to

state sj on (non-epsilon) symbol a,add a transition from q to sj on symbol a

(For each transition from state sj tostate q on (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 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 Conversion processes between

DFAs, 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 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 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}Q1Q2,12, 3, q30,F1F2) where 3 is just 12 plus the following epsilon

transitions: q30 q10 and q30 q20

M3 recognizes L3

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 By De Morgan’s Law,

L1 L2 = ( L1 L2 )

Applications of the constructions provided for and complementation provide a construction for

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 = (Q1Q2, 12, 3, q10, F2) where 3 is just 12 plus the following epsilon

transitions: q1i q20 for all q1i in F1

M3 recognizes L3

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