Non Deterministic Automata: Costas Busch - RPI 1

Non Deterministic Automata
Costas Busch - RPI 1

Nondeterministic Finite Accepter (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 q1 a 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
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
q1 a q2
a
q0
a
q3

Second Choice
a a
q1 a q2
a
q0
a
No transition:
q3
the automaton hangs

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

An NFA accepts a string:
when there is a computation of the NFA
that accepts the string
AND
all the input is consumed and the automaton
is in a final state

Example
aa is accepted by the NFA:
“accept”
q1 a q2 q1 a q2
a a
q0
a
q0
a
q3 q3 “reject”
because this
computation
accepts aa Costas Busch - RPI 14
Rejection example
q1 a q2
a
q0
a
q3

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

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

An NFA rejects a string:
when there is no computation of the NFA
that accepts the string:
• All the input is consumed and the

automaton is in a non final state
OR
• The input cannot be consumed

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

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
a
q0 No transition:
a
the automaton hangs
q3

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

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

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

Second Choice
a a a
q1 a q2
a
q0
a
No transition:
q3
the automaton hangs

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

aaa is rejected by the NFA:
“reject”
q1 a q2 q1 a q2
a a
q0
a
q0
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

(read head does not move)
a a
q0 a q1  q2 a q3

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
q0 a q1  q2 a q3
No transition:
the automaton hangs
a a a
“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
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
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 : Final states
Transition Function 
  q0 , 1   q1
0
q0 q1 0, 1 q
2
1

 (q1,0)  {q0 , q2}
0
q0 q1 0, 1 q
2
1

 (q0 ,  )  {q0 , q2}
0
q0 q1 0, 1 q
2
1

 (q2 ,1)  
0
q0 q1 0, 1 q
2
1

Extended Transition Function  *
 *  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

Formally
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
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 * {aa}

Formally
The language accepted by NFA M is:
L M    w1, w2 , w3 ,...
where  * (q0 , wm )  {qi , q j ,..., qk ,}
and there is some qk  F (final state)

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

NFAs accept the Regular
Languages

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

Example of equivalent machines
NFA M1
0
L M1   {10} *
q0 q1
1
DFA M2 0,1
0
L M 2   {10} *
q0 q1 1 q2
1
0
We will prove:

Languages
Regular
accepted
Languages
by NFAs
Languages
accepted
by DFAs
NFAs and DFAs have the
same computation power
Step 1
Languages
accepted  Regular
Languages
by NFAs
Proof: Every DFA is trivially an NFA
Any language L accepted by a DFA

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

equivalent DFA
Any language L accepted by an NFA

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

Convert NFA to DFA
a
NFA M
q a
0 q  q 1 2
b
DFA M
 q0  a
 q1, q2 

Convert NFA to DFA
a
NFA M
q a
0 q  q 1 2
b
DFA M
 q0  a
 q1, q2 
b

Convert NFA to DFA
a
NFA M
q a
0 q  q 1 2
b
a
DFA M
 q0  a
 q1, q2 
b

Convert NFA to DFA
a
NFA M
q a
0 q  q 1 2
b
b a
DFA M
 q0  a
 q1, q2 
b

Convert NFA to DFA
a
NFA M
q a
0 q  q 1 2
b
b a
DFA M
 q0  a
 q1, q2 
b
 a, b
Convert NFA to DFA
a
NFA M
q a
0 q  q 1 2
b
L M   L(M )
a
DFA M b
 q0  a
 q1, q2 
b
 a, b
NFA to DFA: Remarks
We are given an NFA M
We want to convert it
to an equivalent DFA M 
With L M   L(M )
If the NFA has states
q0 , q1, q2 ,...
the DFA has states in the powerset
,  q0  ,  q1 ,  q1, q2  ,  q3 , q4 , q7  ,....

Procedure NFA to DFA
1. Initial state of NFA: q0
Initial state of DFA:  q0 

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

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

 *  qi , a  ,
 *  q j , a ,  {qi , qj ,..., qm
}
...
Add transition to DFA
 {qi , q j ,..., qm }, a   {qi , qj ,..., qm
}
Exampe
M a
NFA
q0 a q1  q2
b
 * (q0 , a )  {q1, q2 }
DFA M 
 q0  a
 q1, q2 
   q0  , a    q1, q2 
Repeat Step 2 for all letters in alphabet,

until
no more transitions can be added.

Example
M a
NFA
q0 a q1  q2
b
b a
DFA M
 q0  a
 q1, q2 
b
 a, b
3. For any DFA state {qi , q j ,..., qm }
If some q j is a final state in the NFA
Then, {qi , q j ,..., qm }

is a final state in the DFA

Example
M a
NFA
q0 a q1  q2 q1  F
b
a
DFA M b
 q0  a
 q1, q2 
b  q1, q2   F 
 a, b
Theorem
Take NFA M
Apply procedure to obtain DFA M
Then M and M are equivalent :
L M   L M  

Proof
L M   L M 
L M   L M   AND L M   L M  

First we show: L M   L M  
Take arbitrary: w L(M )
We will prove: w  L(M )

w L(M )
M: q0 w qf
w   1 2  k
1 2 k
M: q0 qf

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

Proof by induction on |v|
Induction Basis: v  a1
a1
M: q0 qi
a1
M:
{q0 } {qi ,}

Induction hypothesis: 1 | v | k
v  a1a2 ak
a1 a2 ak
M: q0 qi qj qc qd
a1 a2 ak
M:
{q0} {qi ,} {q j ,} {qc ,} {qd ,}

Induction Step: | v | k  1
v  a1a2 ak ak 1  vak 1
   
v
a1 a2 ak
M: q0 qi qj qc qd
v
a1 a2 ak
M:
{q0} {qi ,} {q j ,} {qc ,} {qd ,}
v
Induction Step: | v | k  1
v  a1a2 ak ak 1  vak 1
   
v
a1 a2 ak ak 1
M: q0 qi qj qc qd qe
v
a1 a2 ak ak 1
M:
{q0} {qi ,} {q j ,} {qc ,} {qd ,} {qe ,}
v
Therefore if w L(M )
w   1 2  k
1 2 k
M: q0 qf
1 2 k
M:
{q0 } {q f ,}
w  L(M )
We have shown: L M   L M  
We also need to show: L M   L M  
(proof is similar)

Non Deterministic Automata: Costas Busch - RPI 1

Uploaded by

Document Information

Original Description:

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 Automata: Costas Busch - RPI 1

Uploaded by

Copyright:

Available Formats

Non Deterministic Automata

Costas Busch - RPI 1

Costas Busch - RPI 2

Costas Busch - RPI 3

Two choices q1 a q2 No transition

Costas Busch - RPI 4

Costas Busch - RPI 5

Costas Busch - RPI 6

Costas Busch - RPI 7

Costas Busch - RPI 8

Costas Busch - RPI 9

Costas Busch - RPI 10

Costas Busch - RPI 11

Costas Busch - RPI 12

Costas Busch - RPI 13

aa is accepted by the NFA:

Costas Busch - RPI 15

Costas Busch - RPI 16

Costas Busch - RPI 17

Costas Busch - RPI 18

Costas Busch - RPI 19

Costas Busch - RPI 20

• All the input is consumed and the

• The input cannot be consumed

a is rejected by the NFA:

All possible computations lead to rejection

Costas Busch - RPI 23

Costas Busch - RPI 24

Costas Busch - RPI 25

Costas Busch - RPI 26

Costas Busch - RPI 27

Costas Busch - RPI 28

Costas Busch - RPI 29

Costas Busch - RPI 30

All possible computations lead to rejection

Costas Busch - RPI 32

Costas Busch - RPI 33

Costas Busch - RPI 34

Costas Busch - RPI 35

Costas Busch - RPI 36

Costas Busch - RPI 37

Costas Busch - RPI 39

Costas Busch - RPI 40

Costas Busch - RPI 41

String aaa is rejected

Costas Busch - RPI 44

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

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

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

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

Costas Busch - RPI 71

 *  q0 , abaa    q4 , q5 aaba  L(M )

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

Costas Busch - RPI 76

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

and there is some qk  F (final state)

Costas Busch - RPI 77

Costas Busch - RPI 78

Costas Busch - RPI 79

Definition for Automata:

Machine M1 is equivalent to machine M 2

Costas Busch - RPI 80