Non Deterministic Finite Automata

Non-Deterministic
Finite Automata
Fall 2006 Costas Busch - RPI 1

Nondeterministic Finite Automaton (NFA)
Alphabet = {a}
q1 a q2
a
q0
a
q3

Alphabet = {a}
Two choices q1 a q2
a
q0
a
q3

Alphabet = {a}
Two choices a
q1 q2 No transition
a
q0
a
q3 No transition

First Choice
a a
q1 a q2
a
q0
a
q3

First Choice
a a
q1 a q2
a
q0
a
q3

First Choice
a a
All input is consumed
q1 a q2 “accept”
a
q0
a
q3

Second Choice
a a
q1 a q2
a
q0
a
q3

Second Choice
a a
Input cannot be consumed
q1 a q2
a
q0 Automaton Halts
a
q3 “reject”

An NFA accepts a string:
if there is a computation of the NFA
that accepts the string
i.e., all the input string is processed and the

automaton is in an accepting state

aa is accepted by the NFA:
“accept”
q1 a q2 q1 a q2
a a
q0 q0
a a
q3 q3 “reject”
because this
this computation
computation
is ignored
accepts aa
Rejection example
q1 a q2
a
q0
a
q3

First Choice
a
“reject”
q1 a q2
a
q0
a
q3

Second Choice
q1 a q2
a
q0
a
q3

Second Choice
q1 a q2
a
q0
a
q3 “reject”

Another Rejection example
a a a
q1 a q2
a
q0
a
q3

First Choice
a a a
q1 a q2
a
q0
a
q3

First Choice
a a a
q1 a q2 “reject”
a
q0
a
Automaton halts
q3

Second Choice
a a a
q1 a q2
a
q0
a
q3

Second Choice
a a a
q1 a q2
a
q0 Automaton halts
a
q3 “reject”

An NFA rejects a string:
if there is no computation of the NFA
that accepts the string.
For each computation:

• All the input is consumed and the
automaton is in a non final state
OR
• The input cannot be consumed
a is rejected by the NFA:
“reject”
q1 a q2 a
q1 q2
a a
q0 q0
a a
q3 “reject” q3
All possible computations lead to rejection

aaa is rejected by the NFA:
“reject”
q1 a q2 q1 a q2
a a
q0 q0
a a
q3 q3 “reject”
All possible computations lead to rejection

Language accepted: L  {aa}
q1 a q2
a
q0
a
q3

Lambda Transitions
q0 a q1  q2 a q3

a a
q0 a q1  q2 a q3

a a
q0 a q1  q2 a q3

input tape head does not move
a a
q0 a q1  q2 a q3

all input is consumed
a a
“accept”
q0 a q1  q2 a q3
String aa is accepted
Rejection Example
a a a
q0 a q1  q2 a q3

a a a
q0 a q1  q2 a q3

(read head doesn’t move)
a a a
q0 a q1  q2 a q3

a a a
Automaton halts
“reject”
q0 a q1  q2 a q3
String aaa is rejected

Language accepted: L  {aa}
q0 a q1  q2 a q3

Another NFA Example
q0 a q1 b q2  q3

a b
q0 a q1 b q2  q3

a b
q0 a q1 b q2  q3

a b
“accept”
q0 a q1 b q2  q3

Another String
a b a b
q0 a q1 b q2  q3

a b a b
q0 a q1 b q2  q3

a b a b
q0 a q1 b q2  q3

a b a b
q0 a q1 b q2  q3

a b a b
q0 a q1 b q2  q3

a b a b
q0 a q1 b q2  q3

a b a b
“accept”
q0 a q1 b q2  q3

Language accepted
L  ab, abab, ababab, ...


 ab
q0 a q1 b q2  q3

Another NFA Example
0
q0 q1 0, 1 q2
1

Language accepted
L(M ) = {λ, 10, 1010, 101010, ...}

= {10}*
0
q0 q1 0, 1 q2
1 (redundant
state)

Remarks:
•The  symbol never appears on the
input tape
•Simple automata:
M1 M2
q0 q0
L(M1 ) = {} L(M 2 ) = {λ}

•NFAs are interesting because we can
express languages easier than DFAs
NFA M1 DFA M2 a
q2
q0 a q1
a
q0 a q1
L( M1 ) = {a} L( M 2 ) = {a}
Formal Definition of NFAs
M  Q, ,  , q0 , F 
Q: Set of states, i.e. q0 , q1, q2 

: Input aplhabet, i.e. a, b  
: Transition function
q0 : Initial state
F: Accepting states
Transition Function 
 q , x   q1, q2,, qk 
q1
x resulting states with
q x
q1 following one transition
x
with symbol x
qk
 q0 , 1  q1
0
q0 q1 0, 1 q
2
1

 (q1,0)  {q0 , q2}
0
q0 q1 0, 1 q
2
1

 (q0 ,  )  {q2 }
0
q0 q1 0, 1 q
2
1

 (q2 ,1)  
0
q0 q1 0, 1 q
2
1

*
Extended Transition Function 
Same with  but applied on strings
 q0 , a   q1 
*
q4 q5
a a
q0 a q1 b q2  q3

 q0 , aa   q4 , q5 
*
q4 q5
a a
q0 a q1 b q2  q3

 q0 , ab   q2 , q3, q0 
*
q4 q5
a a
q0 a q1 b q2  q3

Special case:
for any state q
q   q ,  
*

In general
q j   qi ,w  : there is a walk from qi to q j
*
with label w
qi w qj
w  1 2  k
1 2 k
qi qj

The Language of an NFA M
The language accepted by M is:
LM   w1,w2,...wn 
where  (q0 ,wm )  {qi ,..., qk ,, q j }

*
and there is some qk  F (accepting state)

wm  LM 
 (q0 ,w m )
*
qi
wm
q0 w
qk qk  F
m
wm qj

F  q0 ,q5 
q4 q5
a a
q0 a q1 b q2  q3


 q0 , aa   q4 , q5
*
 aa  L(M )
F
F  q0 ,q5 
q4 q5
a a
q0 a q1 b q2  q3


 q0 , ab   q2, q3, q0
*
 ab LM 
F
F  q0 ,q5 
q4 q5
a a
q0 a q1 b q2  q3


 q0 , abaa   q4 , q5
*
 aaba  L(M )
F
F  q0 ,q5 
q4 q5
a a
q0 a q1 b q2  q3

 * q0 , aba   q1  aba  LM 

F
q4 q5
a a
q0 a q1 b q2  q3

LM   ab  *  ab  * {aa }

NFAs accept the Regular
Languages

Equivalence of Machines
Definition:
Machine M1 is equivalent to machine M2
if L M1   L M 2 

Example of equivalent machines
NFA M1
LM1   {10} * 0
q0 q1
1
DFA M2 0,1
LM 2   {10} * 0
q0 q1 1 q2
1
0
Theorem:

Languages
Regular
accepted
Languages
by NFAs
Languages
accepted
by DFAs
NFAs and DFAs have the same computation power,

accept the same set of languages
Proof: we only need to show
Languages
accepted
by NFAs
 Regular
Languages
AND
Languages
accepted  Regular
Languages
by NFAs

Proof-Step 1
Languages
accepted
by NFAs
 Regular
Languages
Every DFA is trivially an NFA
Any language L accepted by a DFA

is also accepted by an NFA
Proof-Step 2
Languages
accepted
by NFAs
 Regular
Languages
Any NFA can be converted to an

equivalent DFA
Any language L accepted by an NFA

is also accepted by a DFA
Conversion NFA to DFA
NFA M
a
q a q 0
 q 1 2
b
DFA M
q0 

 * (q0 , a )  {q1 , q2 }
NFA M a
q0 a q1  q2
b
DFA M
q0  a
q1,q2

 * (q0 , b )   empty set
NFA M a
q0 a q1  q2
b
DFA M
q0  a
q1,q2
b
 trap state
 (q1 , a )  {q1 , q2 }
*
NFA M a  * (q2 , a )  
q0 a q1  q2 union
b q1,q2
a
DFA M
q0  a
q1,q2
b

 (q1 , b )  {q0 }
*
NFA M a  * (q2 , b )  {q0 }

a  union
q0 q1 q2
b q0 
a
DFA M b
q0  a
q1,q2
b

NFA M a
q0 a q1  q2
b
a
DFA M b
q0  a
q1,q2
b
 a, b trap state
END OF CONSTRUCTION
NFA M a
q0 a q1  q2 q1  F
b
a
DFA M b
q0  a
q1,q2
b
q1, q2  F 
 a, b
General Conversion Procedure
Input: an NFA M
Output: an equivalent DFA M 

with LM   L(M )

The NFA has states q0 , q1, q2 ,...
The DFA has states from the power set
, q0 , q1 , q0 , q1 , q1, q2, q3, ....

Conversion Procedure Steps
step
1. Initial state of NFA: q0
Initial state of DFA: q0 

Example
NFA M a
q0 a q1  q2
b
DFA M
q0 

step
2. For every DFA’s state {qi , q j ,..., qm }
compute in the NFA

 * qi , a 

  * qj ,a  Union
 {qk , ql,..., qn }
...
  * qm , a 
add transition to DFA
 {qi , qj ,..., qm }, a   {qk , ql,..., qn }
Example  * (q0 , a)  {q1, q2}
NFA M a
q0 a q1  q2
b
 q0 , a   q1, q2 
DFA M
q0  a
q1,q2

step
3. Repeat Step 2 for every state in DFA and
symbols in alphabet until no more states
can be added in the DFA

Example
NFA M a
q0 a q1  q2
b
a
DFA M b
q0  a
q1,q2
b
 a, b
step
4. For any DFA state {qi , q j ,..., qm }
if some q j is accepting state in NFA
Then, {qi , q j ,..., qm }

is accepting state in DFA

Example
NFA M a
q0 a q1  q2 q1  F
b
a
DFA M b
q0  a
q1,q2
b
q1, q2  F 
 a, b
Lemma:
If we convert NFA M to DFA M 
then the two automata are equivalent:
L M   L M  
Proof:
We only need to show: L M   L  M  
AND
L M   L  M  
First we show: L M   L  M  
We only need to prove:
w L(M ) w  L(M )

NFA
Consider w L(M )
q0 w qf
symbols
w  1 2  k
1 2 k
q0 qf

symbol
i
qi qj
denotes a possible sub-path like
symbol
  i 
qi qj

We will show that if w L(M )
w  1 2  k
1 2 k
NFA M: q0 qf
then
1 2 k
DFA M:
{q0 } {q f ,}
state
w  L(M ) state
label label
More generally, we will show that if in M:
(arbitrary string) v  a1a2 an
a1 a2 an
NFA M: q0 qi qj ql qm
then
M:
a1 a2 an
DFA
{q0 } {qi ,} {q j ,} {ql ,} {qm ,}

Proof by induction on |v|
Induction Basis: |v | 1 v  a1
a1
NFA M: q0 qi
M:
a1
DFA
{q0 } {qi ,}
is true by construction of M 

Induction hypothesis: 1 | v | k
v  a1a2 ak
Suppose that the following hold

a1 a2 ak
NFA M: q0 qi qj qc qd
M:
a1 a2 ak
DFA
{q0 } {qi ,} {q j ,} {qc ,} {qd ,}

Induction Step: | v | k  1
v  a1a2 ak ak 1  vak 1
 
v
Then this is true by construction of M 
a1 a2 ak ak 1
NFA M: q0 qi qj qc qd qe
v
M:
a1 a2 ak ak 1
DFA
{q0 } {qi ,} {q j ,} {qc ,} {qd ,} {qe ,}
Fall 2006
v
Costas Busch - RPI 101
Therefore if w L(M )
w  1 2  k
1 2 k
q0 qf
NFA M:
then
1 2 k
DFA M:
{q0 } {q f ,}
w  L(M )
We have shown: L M   L  M  
With a similar proof

we can show: L M   L  M  
Therefore: LM   LM 
END OF LEMMA PROOF


Non Deterministic Finite Automata

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Non Deterministic Finite Automata

Uploaded by

Copyright:

Available Formats

Non-Deterministic

Fall 2006 Costas Busch - RPI 1

Fall 2006 Costas Busch - RPI 2

Fall 2006 Costas Busch - RPI 3

Fall 2006 Costas Busch - RPI 4

Fall 2006 Costas Busch - RPI 5

Fall 2006 Costas Busch - RPI 6

Fall 2006 Costas Busch - RPI 7

Fall 2006 Costas Busch - RPI 8

Fall 2006 Costas Busch - RPI 9

i.e., all the input string is processed and the

Fall 2006 Costas Busch - RPI 10

Fall 2006 Costas Busch - RPI 12

Fall 2006 Costas Busch - RPI 13

Fall 2006 Costas Busch - RPI 14

Fall 2006 Costas Busch - RPI 15

Fall 2006 Costas Busch - RPI 16

Fall 2006 Costas Busch - RPI 17

Fall 2006 Costas Busch - RPI 18

Fall 2006 Costas Busch - RPI 19

Fall 2006 Costas Busch - RPI 20

For each computation:

All possible computations lead to rejection

All possible computations lead to rejection

Fall 2006 Costas Busch - RPI 24

Fall 2006 Costas Busch - RPI 25

Fall 2006 Costas Busch - RPI 26

Fall 2006 Costas Busch - RPI 27

Fall 2006 Costas Busch - RPI 28

Fall 2006 Costas Busch - RPI 30

Fall 2006 Costas Busch - RPI 31

Fall 2006 Costas Busch - RPI 32

String aaa is rejected

Fall 2006 Costas Busch - RPI 34

L  ab, abab, ababab, ...

L(M ) = {λ, 10, 1010, 101010, ...}

L(M1 ) = {} L(M 2 ) = {λ}

Q: Set of states, i.e. q0 , q1, q2 

for any state q

Fall 2006 Costas Busch - RPI 60

Fall 2006 Costas Busch - RPI 61

where  (q0 ,wm )  {qi ,..., qk ,, q j }

and there is some qk  F (accepting state)

Fall 2006 Costas Busch - RPI 63

 * q0 , aba   q1  aba  LM 

LM   ab  *  ab  * {aa }

Fall 2006 Costas Busch - RPI 68

Fall 2006 Costas Busch - RPI 69

Machine M1 is equivalent to machine M2

Fall 2006 Costas Busch - RPI 70

NFAs and DFAs have the same computation power,

Fall 2006 Costas Busch - RPI 73

Every DFA is trivially an NFA

Any language L accepted by a DFA

Any NFA can be converted to an

Any language L accepted by an NFA

Fall 2006 Costas Busch - RPI 76

Fall 2006 Costas Busch - RPI 77

NFA M a  * (q2 , b )  {q0 }

Output: an equivalent DFA M 

Fall 2006 Costas Busch - RPI 83

The DFA has states from the power set

, q0 , q1 , q0 , q1 , q1, q2, q3, ....