Dfa & Nfa

Deterministic Finite Automata (DFA)
Non-Deterministic Finite Automata (NFA)
CS301: Theory of Automata:

Finita Automata
February 13, 2012
CS301: Theory of Automata:Finita Automata
-NFA
Layout
1 Deterministic Finite Automata (DFA)
Definition
Other Representations
and Language of a DFA
2 Non-Deterministic Finite Automata (NFA)
Defintion, and Language

Equivalence between NFA and DFA
3 -NFA
and language
Definition, -closures, ,
-NFA
Definition
Layout
Definition

3 -NFA
and language
-NFA
Definition
DFA
Automaton:
dictionary.com: something capable of acting automatically or
without an external motive force
the automata in this course will be used to check if certain
strings belong to a language.
Finite: finite number of states
Deterministic: transition to only 1 state per symbol
-NFA
Definition
A DFA, A, is defined as a five-tuple

A = (Q, , , q0 , F )
Q set of states
the alphabet, set of input symbols
transition function, : Q Q
q0 initial state
F set of final states
A = {{S0 , S1 , S2 }, {0, 1}, , S0 , {S0 }}
(S0 , 0) = S0 , (S0 , 1) = S1
(S1 , 0) = S2 , (S1 , 1) = S0
(S2 , 0) = S1 , (S2 , 1) = S2
-NFA
Layout
Definition

3 -NFA
and language
-NFA
Transition Diagram
Graph Vertices: states
Directed, labeled edges of the graph: transitions
The (single) starting/initial state is indicated by
The ( 1) accepting/final states are indicated by double circles
-NFA
Transition Table
The (single) starting/initial state is indicated by

The ( 1) accepting/final states are indicated by *
* S0
S1
S2
0
S0
S2
S1
1
S1
S0
S2
-NFA
Layout
Definition

3 -NFA
and language
-NFA
The DFA as a String Processor
The DFA reads a string symbol by symbol and transitions between

its states as it does so.
Example: A DFA that accepts
{x01y | x, y {0, 1} }
-NFA
A Transition Function for Strings

for a string, w = xa
Extended transition function, ,
) = q
(q,
w ) = ((q,
x), a)
(q,
Example: DFA accepts {w | w has an even numbers of 0s and 1s}
0 , 010010) =
0
1
(q
(q
0 , 01001), 0) = . . .
(
q0 q2 q1
q1 q3 q0
q2 q0 q3
q3 q1 q2
-NFA
Regular Languages
The language of a DFA, A = (Q, , , qo , F ), is defined by

0, w ) F }
L(A) = {w | (q
If L is L(A) for some A, then L is a regular language.
-NFA
Layout
Definition

3 -NFA
and language
-NFA
Layout
Definition

3 -NFA
and language
-NFA
Example
Example: An NFA that accepts {x01 | x {0, 1} }

Process 01001.
A state in an NFA may have any number (including 0) of
transitions per input symbol.
If, while reading a string, no transition is possible, the
corresponding thread dies.
-NFA
Defintion
L(A) = {Q, , , q0 , F }
: Q 2Q
q0
q1
q2
0
{q0 , q1 }
1
{q0 }
{q2 }
for w = xa
) = {q}
(q,
x) = {p1 , p2 , . . . , pk }
Assume (q,
S
w ) = k (pi , a)
Then, (q,
i=1
-NFA
Language of an NFA
The language of an NFA, A = (Q, , , qo , F ), is defined by

0 , w ) F 6= }
L(A) = {w | (q
-NFA
Layout
Definition

3 -NFA
and language
-NFA
Subset Construction
Given an NFA, N = {QN , , N , q0 , FN }, it is possible to construct

a DFA, D = {QD , , D , {q0 }, FD }, such that L(N) = L(D).
QD = 2QN
FD = {S | S QD , S FN 6= }
S
S QD , a D (S, a) = pS N (p, a)
The above subset construction leads to excessive states, some of
which are never reached.
Use a lazy construction instead.
-NFA
Proof
Theorem: If D = {QD , , D , {q0 }, FD } is a DFA constructed from
an NFA, N = {QN , , N , q0 , FN }, using the subset construction
above, then L(D) = L(N).
Proof (by induction): Imagine a string w . We want to prove
that
D ({q0 }, w ) = N (q0 , w )
Base case: w = .
LHS: D ({q0 }, ) = {q0 } (by definition of D )
RHS: N (q0 , ) = {q0 } (by definition of N )
Thus LHS RHS.
Induction hypothesis: Assume D ({q0 }, w ) = N (q0 , w ) is true
for |w | = n.
-NFA
-NFA
Proof (contd)
Induction step: We want to investigate whether, for |w | = n + 1
D ({q0 }, w ) = N (q0 , w )
(1)
Imagine w = xa where |x| = n and |a| = 1.

Then, from the induction hypothesis, we know that
D ({q0 }, x) = N (q0 , x). Let the set of states be {p1 , p2 , . . . , pk }.
LHS of (1):
D ({q0 }, w ) = D ({q0 }, xa)
(w = xa)
= D (D ({q0 }, x), a)
(definition of D )
= D ({p1 , p2 , . . . , pk }, a) (induction hypothesis)
Sk
=
(definition of D )
i=1 N (pi , a)
Proof (contd)
S
RHS of (1): N (q0 , w ) = ki=1 N (pi , a)
(induction hypothesis and definition of N )
Thus, LHS RHS
Also, D and N both accept w iff D ({q0 }, w ) or N (q0 , w ) contain
an element on FN .
-NFA
Proof (contd)
Theorem: A language L is accepted by some DFA iff L is accepted
by some NFA.
Proof: Need to prove the if part and the only if part.
if part proved above, i.e. L = L(N) L = L(D)
only if part: L = L(D) L = L(N):
Given a DFA, D = {Q, , D , q0 , F }, construct an NFA,
N = {Q, , N , q0 , F }, such that
if D (q, a) = p, then N (q, a) = {p}
It can then be shown (by induction on |w |) that if D (q0 , w ) = p,
then N (q0 , a) = {p}
Thus, w is accepted by D iff w is accepted by N, i.e.
L(N) = L(D)
-NFA
Layout
Definition

3 -NFA
and language
-NFA
and language
Layout
Definition

3 -NFA
and language
-NFA
and language
Example
NFA with transitions, e.g.
Process strings: 01, 001, 100

-NFA
and language
Formal Defintion
5-tuple: (Q, , , q0 , F )
Q, , q0 , F as before
: Q { {}} 2Q
-NFA
and language
-closure
ECLOSE (q) is the union of

{q}
{s | p ECLOSE (q), (p, ) = s}
ECLOSE (S) =
qS
ECLOSE (q)
Examples from the machine shown above.
-NFA
and language
and Language
w)
(q,
) = ECLOSE (q)
(q,
[
xa) = ECLOSE (
(q,
s(q,x)
0 , w ) F 6= )}
L(A) = {w | (q
(s, a))
-NFA
and language
Eliminating -transitions
Given an -NFA, E = (QE , E , E , q0E , FE ), construct a DFA,
D = (QD , D , D , q0D , FD ), such that L(D) = L(E ).
QD = 2QE ( closed sets only)
D = E
qoD = ECLOSE (q0E )
F = {S | S QD , S FE 6= }
[
D (S, a) = ECLOSE (
E (p, a))
pS
-NFA
and language
Equivalence proof
Theorem: A language, L, is accepted by an -NFA iff it is accepted

by a DFA.
Proof: Need to prove the if part and the only if part.
if: L = L(D) L = L(E ):
Construct E from D such that L(E ) = L(D).
QE = QD {}
D (q, a) = p E (q, a) = {p}
p QE E (p, ) =
Proof left as exercise.
-NFA
and language
Equivalence proof (contd)

only if: L = L(E ) L = L(D):
E (q0 , w ) = D (ECLOSE (q0 ), w )
Base case: w = .
LHS: E (q0 , ) = ECLOSE (q0 ) (by definition of E )
RHS: D (ECLOSE (q0 ), ) = ECLOSE (q0 ) (by definition of D )
Thus LHS RHS for the base case.
Induction hypothesis: Assume
E (q0 , w ) = D (ECLOSE (q0 ), w ) = {p1 , p2 , . . . , pk }
is true for |w | = k.
-NFA
-NFA
and language
Equivalence proof (contd)

Induction step: Investigate for |w | = k + 1
LHS:
E (q0 , w ) = E (q0 , xa)
(w = xa)
= ECLOSE (pE (q0 ,x) E (p, a))
(def. of E )
= ECLOSE (p{p1 ,p2 ,...,pk } E (p, a)) (ind. hyp.)
RHS:
D (ECLOSE (q0 ), w ) = D (ECLOSE (q0 ), xa)
= D (D (ECLOSE (q0 ), x), a)
= ECLOSE (pECLOSE (q0 ),x) E (p, a))
= ECLOSE (p{p1 ,p2 ,...,pk } E (p, a))
Thus LHS RHS for the base case.
(w = xa
(def. of
(-elim.)
(ind. hyp
Also, D and E both accept w iff E (q0 , w ) or D (ECLOSE (q0 ), w )

contain an element on FE .
Thank You!
-NFA

Dfa & Nfa

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Dfa & Nfa

Caricato da

Copyright:

Formati disponibili

Deterministic Finite Automata (DFA)

Non-Deterministic Finite Automata (NFA)

CS301: Theory of Automata:

February 13, 2012

CS301: Theory of Automata:Finita Automata

Deterministic Finite Automata (DFA)

Non-Deterministic Finite Automata (NFA)

Defintion, and Language

CS301: Theory of Automata:Finita Automata

Deterministic Finite Automata (DFA)

Non-Deterministic Finite Automata (NFA)

Defintion, and Language

CS301: Theory of Automata:Finita Automata

Deterministic Finite Automata (DFA)

Non-Deterministic Finite Automata (NFA)

CS301: Theory of Automata:Finita Automata

Deterministic Finite Automata (DFA)

Non-Deterministic Finite Automata (NFA)

A DFA, A, is defined as a five-tuple

CS301: Theory of Automata:Finita Automata

Deterministic Finite Automata (DFA)

Non-Deterministic Finite Automata (NFA)

Defintion, and Language

CS301: Theory of Automata:Finita Automata

Deterministic Finite Automata (DFA)

Non-Deterministic Finite Automata (NFA)

CS301: Theory of Automata:Finita Automata

Deterministic Finite Automata (DFA)

Non-Deterministic Finite Automata (NFA)

The (single) starting/initial state is indicated by

CS301: Theory of Automata:Finita Automata

Deterministic Finite Automata (DFA)

Non-Deterministic Finite Automata (NFA)

and Language of a DFA

Defintion, and Language

CS301: Theory of Automata:Finita Automata

Deterministic Finite Automata (DFA)

Non-Deterministic Finite Automata (NFA)

and Language of a DFA

The DFA as a String Processor

The DFA reads a string symbol by symbol and transitions between

CS301: Theory of Automata:Finita Automata

Deterministic Finite Automata (DFA)

Non-Deterministic Finite Automata (NFA)

and Language of a DFA

A Transition Function for Strings

CS301: Theory of Automata:Finita Automata

Deterministic Finite Automata (DFA)

Non-Deterministic Finite Automata (NFA)

and Language of a DFA

The language of a DFA, A = (Q, , , qo , F ), is defined by

CS301: Theory of Automata:Finita Automata

Deterministic Finite Automata (DFA)

Non-Deterministic Finite Automata (NFA)

Defintion, and Language

CS301: Theory of Automata:Finita Automata

Deterministic Finite Automata (DFA)

Non-Deterministic Finite Automata (NFA)

Defintion, and Language

Defintion, and Language

CS301: Theory of Automata:Finita Automata

Deterministic Finite Automata (DFA)

Non-Deterministic Finite Automata (NFA)

Theorem: A language, L, is accepted by an -NFA iff it is accepted