FiniteAutomata (1).ppt

1
Hierarchy of languages
Regular Languages
Context-Free Languages
Recursive Languages
Recursively Enumerable Languages
Non-Recursively Enumerable Languages

2
Deterministic Finite State Automata (DFA)
……..
• One-way, infinite tape, broken into cells
• One-way, read-only tape head.
• Finite control, i.e.,
– finite number of states, and
– transition rules between them, i.e.,
– a program, containing the position of the read head, current symbol being scanned,
and the current “state.”
• A string is placed on the tape, read head is positioned at the left end,
and the DFA will read the string one symbol at a time until all symbols
have been read. The DFA will then either accept or reject the string.
Finite
Control
0 1 1 0 0

3
• The finite control can be described by a transition diagram or table:
• Example #1:
1 0 0 1 1
q0 q0 q1 q0 q0 q0
• One state is final/accepting, all others are rejecting.
• The above DFA accepts those strings that contain an even number of
0’s, including the null string, over Sigma = {0,1}
L = {all strings with zero or more 0’s}
• Note, the DFA must reject all other strings
q0
q1
0
0
1
1

4
Note:
• Machine is for accepting a language, language is the purpose!
• Many equivalent machines may accept the same language,
but a machine cannot accept multiple languages!
• Id’s of the characters or states are irrelevant,
you can call them by any names!
Sigma = {0, 1} ≡ {a, b}
States = {q0, q1} ≡ {u, v}, as long as they have
identical (isomorphic) transition table
M1 M2 …. M-inf
L

5
• An equivalent machine to the previous example (DFA for even number
of 0’s):
1 0 0 1 1
q0 q3 q1 q2 q2 q2 accept string
• One state is final/accepting, all others are rejecting.
• The above DFA accepts those strings that contain an even number of
0’s, including null string, over Sigma = {0,1}
• Can you draw a machine for a language by excluding the null string
from the language? L = {all strings with 2 or more 0’s}
q0
q1
0
0 1
q2
1
1
0
q3
1
0

6
• Example #2:
a c c c b accepted
q0 q0 q1 q2 q2 q2
a a c rejected
q0 q0 q0 q1
• Accepts those strings that contain at least two c’s
q1
q0
q2
a
b
a
b
c c
a/b/c

7
q1
q0
q2
a
b
a
b
c c
a/b/c
Inductive Proof (sketch): that the machine correctly accepts strings with at least two c’s
Proof goes over the length of the string.
Base: x a string with |x|=0. state will be q0 => rejected.
Inductive hypothesis: |x|= integer k, & string x is rejected - in state q0 (x must have zero c),
OR, rejected – in state q1 (x must have one c),
OR, accepted – in state q2 (x has already with two c’s)
Inductive steps: Each case for symbol p, for string xp (|xp| = k+1), the last symbol p = a, b or c
xa xb xc
x ends in q0 q0 =>reject
(still zero c =>
should reject)
q0 =>reject
(still zero c =>
should reject)
q1 =>reject
(still zero c =>
should reject)
x ends in q1 q1 =>reject
(still one c => should
reject)
q1 =>reject
(still one c => should
reject)
q2 =>accept
(two c now=>
should accept)
x ends in q2 q2 =>accept
(two c already =>
should accept)
q2 =>accept
(two c already =>
should accept)
q2 =>accept
(two c already =>
should accept)

8
Formal Definition of a DFA
• A DFA is a five-tuple:
M = (Q, Σ, δ, q0, F)
Q A finite set of states
Σ A finite input alphabet
q0 The initial/starting state, q0 is in Q
F A set of final/accepting states, which is a subset of Q
δ A transition function, which is a total function from Q x Σ to Q
δ: (Q x Σ) –> Q δ is defined for any q in Q and s in Σ, and
δ(q,s) = q’ is equal to some state q’ in Q, could be q’=q
Intuitively, δ(q,s) is the state entered by M after reading symbol s while in
state q.

9
• Revisit example #1:
Q = {q0, q1}
Σ = {0, 1}
Start state is q0
F = {q0}
δ:
0 1
q0 q1 q0
q1 q0 q1
q0
q1
0
0
1
1

10
• Revisit example #2:
Q = {q0, q1, q2}
Σ = {a, b, c}
Start state is q0
F = {q2}
δ: a b c
q0 q0 q0 q1
q1 q1 q1 q2
q2 q2 q2 q2
• Since δ is a function, at each step M has exactly one option.
• It follows that for a given string, there is exactly one computation.
q1
q0
q2
a
b
a
b
c c
a/b/c

11
Extension of δ to Strings
δ^ : (Q x Σ*) –> Q
δ^(q,w) – The state entered after reading string w having started in state q.
Formally:
1) δ^(q, ε) = q, and
2) For all w in Σ* and a in Σ
δ^(q,wa) = δ (δ^(q,w), a)

12
• Recall Example #1:
• What is δ^(q0, 011)? Informally, it is the state entered by M after
processing 011 having started in state q0.
• Formally:
δ^(q0, 011) = δ (δ^(q0,01), 1) by rule #2
= δ (δ ( δ^(q0,0), 1), 1) by rule #2
= δ (δ (δ (δ^(q0, λ), 0), 1), 1) by rule #2
= δ (δ (δ(q0,0), 1), 1) by rule #1
= δ (δ (q1, 1), 1) by definition of δ
= δ (q1, 1) by definition of δ
= q1 by definition of δ
• Is 011 accepted? No, since δ^(q0, 011) = q1 is not a final state.
q0
q1
0
0
1
1

13
• Note that:
δ^ (q,a) = δ(δ^(q, ε), a) by definition of δ^, rule #2
= δ(q, a) by definition of δ^, rule #1
• Therefore:
δ^ (q, a1a2…an) = δ(δ(…δ(δ(q, a1), a2)…), an)
• However, we will abuse notations, and use δ in place of δ^:
δ^(q, a1a2…an) = δ(q, a1a2…an)

14
• Example #3:
• What is δ(q0, 011)? Informally, it is the state entered by M after
processing 011 having started in state q0.
• Formally:
δ(q0, 011) = δ (δ(q0,01), 1) by rule #2
= δ (δ (δ(q0,0), 1), 1) by rule #2
= δ (δ (q1, 1), 1) by definition of δ
• Is 011 accepted? No, since δ(q0, 011) = q1 is not a final state.
• Language?
• L ={ all strings over {0,1} that has 2 or more 0 symbols}
q1
q0
q2
1 1
0
0
1
0

15
• Recall Example #3:
• What is δ(q1, 10)?
δ(q1, 10) = δ (δ(q1,1), 0) by rule #2
• Is 10 accepted? No, since δ(q0, 10) = q1 is not a final state. The fact
that δ(q1, 10) = q2 is irrelevant, q1 is not the start state!
0
q1
q0
q2
1 1
0
1
0

16
Definitions related to DFAs
• Let M = (Q, Σ, δ,q0,F) be a DFA and let w be in Σ*. Then w is accepted by M
iff δ(q0,w) = p for some state p in F.
• Let M = (Q, Σ, δ,q0,F) be a DFA. Then the language accepted by M is the
set:
L(M) = {w | w is in Σ* and δ(q0,w) is in F}
• Another equivalent definition:
L(M) = {w | w is in Σ* and w is accepted by M}
• Let L be a language. Then L is a regular language iff there exists a DFA M
such that L = L(M).
• Let M1 = (Q1, Σ1, δ1, q0, F1) and M2 = (Q2, Σ2, δ2, p0, F2) be DFAs. Then M1
and M2 are equivalent iff L(M1) = L(M2).

17
• Notes:
– A DFA M = (Q, Σ, δ,q0,F) partitions the set Σ* into two sets: L(M) and
Σ* - L(M).
– If L = L(M) then L is a subset of L(M) and L(M) is a subset of L (def. of set
equality).
– Similarly, if L(M1) = L(M2) then L(M1) is a subset of L(M2) and L(M2) is a subset
of L(M1).
– Some languages are regular, others are not. For example, if
Regular: L1 = {x | x is a string of 0's and 1's containing an even
number of 1's} and
Not-regular: L2 = {x | x = 0n1n for some n >= 0}
• Can you write a program to “simulate” a given DFA, or any arbitrary input DFA?
• Question we will address later:
– How do we determine whether or not a given language is regular?

18
• Give a DFA M such that:
L(M) = {x | x is a string of 0’s and 1’s and |x| >= 2}
Prove this by induction
q1
q0
q2
0/1
0/1
0/1

19
L(M) = {x | x is a string of (zero or more) a’s, b’s and c’s such
that x does not contain the substring aa}
Logic:
In Start state (q0): b’s and c’s: ignore – stay in same state
q0 is also “accept” state
First ‘a’ appears: get ready (q1) to reject
But followed by a ‘b’ or ‘c’: go back to start state q0
When second ‘a’ appears after the “ready” state: go to reject state q2
Ignore everything after getting to the “reject” state q2
q2
q0
a
a/b/c
a
q1
b/c
b/c

20
L(M) = {x | x is a string of a’s, b’s and c’s such that x
contains the substring aba}
Logic: acceptance is straight forward, progressing on each expected
symbol
However, rejection needs special care, in each state (for DFA, we will see
this becomes easier in NFA, non-deterministic machine)
q2
q0
a
a/b/c
b
q1
c
b/c a
b/c
q3
a

21
L(M) = {x | x is a string of a’s and b’s such that x
contains both aa and bb}
First do, for a language where ‘aa’ comes before ‘bb’
Then do its reverse; and then parallelize them.
Remember, you may have multiple “final” states, but only one “start”
state
q0
b
q7
q5
q4 q6
b
b
b
a
q2
q1 q3
a
a
a
b
a/b
b
a
a
a b

22
• Let Σ = {0, 1}. Give DFAs for {}, {ε}, Σ*, and Σ+.
For {}: For {ε}:
For Σ*: For Σ+:
0/1
q0
0/1
q0
q1
q0
0/1
0/1
0/1
q0 q1
0/1

23
• Problem: Third symbol from last is 1
0/1
q1
q0
q3
1 0/1 q2
0/1
Is this a DFA?
No, but it is a Non-deterministic Finite Automaton

24
Nondeterministic Finite State
Automata (NFA)
• An NFA is a five-tuple:
M = (Q, Σ, δ, q0, F)
δ A transition function, which is a total function from Q x Σ to 2Q
δ: (Q x Σ) –> 2Q :2Q is the power set of Q, the set of all subsets of Q
δ(q,s) :The set of all states p such that there is a transition
labeled s from q to p
δ(q,s) is a function from Q x S to 2Q (but not only to Q)

25
• Example #1: one or more 0’s followed by one or more 1’s
Q = {q0, q1, q2}
Σ = {0, 1}
Start state is q0
F = {q2}
δ: 0 1
q0
q1
q2
{q0, q1} {}
{} {q1, q2}
{q2} {q2}
q1
q0
q2
0 1
0 1
0/1

26
• Example #2: pair of 0’s or pair of 1’s as substring
Q = {q0, q1, q2 , q3 , q4}
Σ = {0, 1}
Start state is q0
F = {q2, q4}
δ: 0 1
q0
q1
q2
q3
q4
{q0, q3} {q0, q1}
{} {q2}
{q2} {q2}
{q4} {}
{q4} {q4}
q0
0/1
0 0
q3
q4
0/1
q1
q2
0/1
1
1

27
• Notes:
– δ(q,s) may not be defined for some q and s (what does that mean?)
– δ(q,s) may map to multiple q’s
– A string is said to be accepted if there exists a path from q0 to some state
in F
– A string is rejected if there exist NO path to any state in F
– The language accepted by an NFA is the set of all accepted strings
• Question: How does an NFA find the correct/accepting path for a
given string?
– NFAs are a non-intuitive computing model
– You may use backtracking to find if there exists a path to a final state
(following slide)
• Why NFA?
– We are primarily interested in NFAs as language defining capability, i.e.,
do NFAs accept languages that DFAs do not?
– Other secondary questions include practical ones such as whether or not
NFA is easier to develop, or how does one implement NFA

28
• Determining if a given NFA (example #2) accepts a given string (001)
can be done algorithmically:
q0 q0 q0 q0
q3 q3 q1
q4 q4 accepted
• Each level will have at most n states:
Complexity: O(|x|*n), for running over a string x
0 0 1
q0
0/1
0
q3
q4
q1
q2
1
1
0
0/1
0/1

29
• Another example (010):
q0 q0 q0 q0
q3 q1 q3
not accepted
• All paths have been explored, and none lead to an accepting state.
0 1 0
q0
0/1
0
q3
q4
q1
q2
1
1
0

30
• Question: Why non-determinism is useful?
– Non-determinism = Backtracking
– Compressed information
– Non-determinism hides backtracking
– Programming languages, e.g., Prolog, hides backtracking => Easy to
program at a higher level: what we want to do, rather than how to do it
– Useful in algorithm complexity study
– Is NDA more “powerful” than DFA, i.e., accepts type of languages that
any DFA cannot?

31
• Let Σ = {a, b, c}. Give an NFA M that accepts:
L = {x | x is in Σ* and x contains ab}
Is L a subset of L(M)? Or, does M accepts all string in L?
Is L(M) a subset of L? Or, does M rejects all strings not in L?
• Is an NFA necessary? Can you draw a DFA for this L?
• Designing NFAs is not as trivial as it seems: easy to create bug
accepting string outside language
q1
q0
q2
a
a/b/c
b
a/b/c

32
• Let Σ = {a, b}. Give an NFA M that accepts:
L = {x | x is in Σ* and the third to the last symbol in x is b}
Is L a subset of L(M)?
Is L(M) a subset of L?
• Give an equivalent DFA as an exercise.
q1
q0
b q3
a/b
a/b
q2
a/b

33
Extension of δ to Strings and Sets of States
• What we currently have: δ : (Q x Σ) –> 2Q
• What we want (why?): δ : (2Q x Σ*) –> 2Q
• We will do this in two steps, which will be slightly different from the
book, and we will make use of the following NFA.
q0
0 1
q1
q4
q3
0 1
q2
0
0
1
0
0

34
• Step #1:
Given δ: (Q x Σ) –> 2Q define δ#: (2Q x Σ) –> 2Q as follows:
1) δ#(R, a) = δ(q, a) for all subsets R of Q, and symbols a in Σ
• Note that:
δ#({p},a) = δ(q, a) by definition of δ#, rule #1 above
= δ(p, a)
• Hence, we can use δ for δ#
δ({q0, q2}, 0) These now make sense, but previously
δ({q0, q1, q2}, 0) they did not.

R
q

}
{p
q

35
• Example:
δ({q0, q2}, 0) = δ(q0, 0) U δ(q2, 0)
= {q1, q3} U {q3, q4}
= {q1, q3, q4}
δ({q0, q1, q2}, 1) = δ(q0, 1) U δ(q1, 1) U δ(q2, 1)
= {} U {q2, q3} U {}
= {q2, q3}

36
• Step #2:
Given δ: (2Q x Σ) –> 2Q define δ^: (2Q x Σ*) –> 2Q as follows:
δ^(R,w) – The set of states M could be in after processing string w, having
started from any state in R.
Formally:
2) δ^(R, ε) = R for any subset R of Q
3) δ^(R,wa) = δ (δ^(R,w), a) for any w in Σ*, a in Σ, and
subset R of Q
• Note that:
δ^(R, a) = δ(δ^(R, ε), a) by definition of δ^, rule #3 above
= δ(R, a) by definition of δ^, rule #2 above
• Hence, we can use δ for δ^
δ({q0, q1, q2}, 101101) they did not.

37
• Example:
What is δ({q0}, 10)?
Informally: The set of states the NFA could be in after processing 10,
having started in state q0, i.e., {q1, q2, q3}.
Formally: δ({q0}, 10) = δ(δ({q0}, 1), 0)
= δ({q0}, 0)
= {q1, q2, q3}
Is 10 accepted? Yes!
q0
0 1
q1
q3
0 1
q2
1
1 0

38
• Example:
What is δ({q0, q1}, 1)?
δ({q0 , q1}, 1) = δ({q0}, 1)  δ({q1}, 1)
= {q0}  {q2, q3}
= {q0, q2, q3}
What is δ({q0, q2}, 10)?
δ({q0 , q2}, 10) = δ(δ({q0 , q2}, 1), 0)
= δ(δ({q0}, 1) U δ({q2}, 1), 0)
= δ({q0}  {q3}, 0)
= δ({q0,q3}, 0)
= δ({q0}, 0)  δ({q3}, 0)
= {q1, q2, q3}  {}
= {q1, q2, q3}

39
• Example:
δ({q0}, 101) = δ(δ({q0}, 10), 1)
= δ(δ(δ({q0}, 1), 0), 1)
= δ(δ({q0}, 0), 1)
= δ({q1 , q2, q3}, 1)
= δ({q1}, 1) U δ({q2}, 1) U δ({q3}, 1)
= {q2, q3} U {q3} U {}
= {q2, q3}
Is 101 accepted? Yes! q3 is a final state.

40
Definitions for NFAs
• Let M = (Q, Σ, δ,q0,F) be an NFA and let w be in Σ*. Then w is
accepted by M iff δ({q0}, w) contains at least one state in F.
• Let M = (Q, Σ, δ,q0,F) be an NFA. Then the language accepted by M
is the set:
L(M) = {w | w is in Σ* and δ({q0},w) contains at least one state in F}

41
Equivalence of DFAs and NFAs
• Do DFAs and NFAs accept the same class of languages?
– Is there a language L that is accepted by a DFA, but not by any NFA?
– Is there a language L that is accepted by an NFA, but not by any DFA?
• Observation: Every DFA is an NFA, DFA is only restricted NFA.
• Therefore, if L is a regular language then there exists an NFA M such
that L = L(M).
• It follows that NFAs accept all regular languages.
• But do NFAs accept more?

42
• Consider the following DFA: 2 or more c’s
Q = {q0, q1, q2}
Σ = {a, b, c}
Start state is q0
F = {q2}
δ: a b c
q0 q0 q0 q1
q1 q1 q1 q2
q2 q2 q2 q2
q1
q0
q2
a
b
a
b
c c
a/b/c

43
• An Equivalent NFA:
Q = {q0, q1, q2}
Σ = {a, b, c}
Start state is q0
F = {q2}
δ: a b c
q0 {q0} {q0} {q1}
q1 {q1} {q1} {q2}
q2 {q2} {q2} {q2}
q1
q0
q2
a
b
a
b
c c
a/b/c

44
• Lemma 1: Let M be an DFA. Then there exists a NFA M’ such that
L(M) = L(M’).
• Proof: Every DFA is an NFA. Hence, if we let M’ = M, then it follows
that L(M’) = L(M).
The above is just a formal statement of the observation from the
previous slide.

45
• Lemma 2: Let M be an NFA. Then there exists a DFA M’ such that L(M) =
L(M’).
• Proof: (sketch)
Let M = (Q, Σ, δ,q0,F).
Define a DFA M’ = (Q’, Σ, δ’,q’
0,F’) as:
Q’ = 2Q Each state in M’ corresponds to a
= {Q0, Q1,…,} subset of states from M
where Qu = [qi0, qi1,…qij]
F’ = {Qu | Qu contains at least one state in F}
q’
0 = [q0]
δ’(Qu, a) = Qv iff δ(Qu, a) = Qv

46
• Example: empty string or start and end with 0
Q = {q0, q1}
Σ = {0, 1}
Start state is q0
F = {q0}
δ: 0 1
q0
q1
{q1} {}
{q0, q1} {q1}
q1
q0
0
0/1
0

47
• Example of creating a DFA out of an NFA (as per the constructive
proof):
-->q0
δ for DFA: 0 1 q1
->q0
[q1]
[ ]
q1
q0
0
0/1
0
{q1}
write as
[q1]
{}
write as
[ ]

48
proof):
δ: 0 1
->q0
[q1]
[ ]
[q01]
q1
q0
0
0/1
0
{q1}
write as
[q1]
{}
{q0,q1}
write as
[q01]
{q1}

49
proof):
δ: 0 1
->q0
[q1]
[ ]
[q01]
q1
q0
0
0/1
0
{q1}
write as
[q1]
{}
{q0,q1}
write as
[q01]
{q1}
[ ] [ ]

50
proof):
δ: 0 1
->q0
[q1]
[ ]
[q01]
q1
q0
0
0/1
0
{q1}
write as
[q1]
{}
{q0,q1}
write as
[q01]
{q1}
[ ] [ ]
[q01] [q1]

51
• Construct DFA M’ as follows:
δ({q0}, 0) = {q1} => δ’([q0], 0) = [q1]
δ({q0}, 1) = {} => δ’([q0], 1) = [ ]
δ({q1}, 0) = {q0, q1} => δ’([q1], 0) = [q0q1]
δ({q1}, 1) = {q1} => δ’([q1], 1) = [q1]
δ({q0, q1}, 0) = {q0, q1} => δ’([q0q1], 0) = [q0q1]
δ({q0, q1}, 1) = {q1} => δ’([q0q1], 1) = [q1]
δ({}, 0) = {} => δ’([ ], 0) = [ ]
δ({}, 1) = {} => δ’([ ], 1) = [ ]
[ ]
1 0
[q0q1]
1
[q1]
0
0/1
[q0]
1
0

52
• Theorem: Let L be a language. Then there exists an DFA M such
that L = L(M) iff there exists an NFA M’ such that L = L(M’).
• Proof:
(if) Suppose there exists an NFA M’ such that L = L(M’). Then by
Lemma 2 there exists an DFA M such that L = L(M).
(only if) Suppose there exists an DFA M such that L = L(M). Then by
Lemma 1 there exists an NFA M’ such that L = L(M’).
• Corollary: The NFAs define the regular languages.

53
• Note: Suppose R = {}
δ(R, 0) = δ(δ(R, ε), 0)
= δ(R, 0)
= δ(q, 0)
= {} Since R = {}
• Exercise - Convert the following NFA to a DFA:
Q = {q0, q1, q2} δ: 0 1
Σ = {0, 1}
Start state is q0 q0
F = {q0}
q1
q2

R
q
{q0, q1} { }
{q1} {q2}
{q2} {q2}

54
• Problem: Third symbol from last is 1
0/1
q1
q0
q3
1 0/1 q2
0/1
Now, can you convert this NFA to a DFA?

55
NFAs with ε Moves
• An NFA-ε is a five-tuple:
M = (Q, Σ, δ, q0, F)
δ A transition function, which is a total function from Q x Σ U {ε} to 2Q
δ: (Q x (Σ U {ε})) –> 2Q
δ(q,s) -The set of all states p such that there is a
transition labeled a from q to p, where a
is in Σ U {ε}
• Sometimes referred to as an NFA-ε other times, simply as an NFA.

56
• Example:
δ: 0 1 ε
q0 - A string w = w1w2…wn is processed
as w = ε*w1ε*w2ε* … ε*wnε*
q1 - Example: all computations on 00:
0 ε 0
q2 q0 q0 q1 q2
:
q3
q0
ε
0/1
q2
1
0
q1
0
q3
ε
0
1
{q0} { } {q1}
{q1, q2} {q0, q3} {q2}
{q2} {q2} { }
{ } { } { }

57
Informal Definitions
• Let M = (Q, Σ, δ,q0,F) be an NFA-ε.
• A String w in Σ* is accepted by M iff there exists a path in M from q0 to a state
in F labeled by w and zero or more ε transitions.
• The language accepted by M is the set of all strings from Σ* that are accepted
by M.

58
ε-closure
• Define ε-closure(q) to denote the set of all states reachable from q by zero or
more ε transitions.
• Examples: (for the previous NFA)
ε-closure(q0) = {q0, q1, q2} ε-closure(q2) = {q2}
ε-closure(q1) = {q1, q2} ε-closure(q3) = {q3}
• ε-closure(q) can be extended to sets of states by defining:
ε-closure(P) = ε-closure(q)
• Examples:
ε-closure({q1, q2}) = {q1, q2}
ε-closure({q0, q3}) = {q0, q1, q2, q3}

P
q
q0
ε
0/1
q2
1
0
q1
0
q3
ε
0
1

59
• What we currently have: δ : (Q x (Σ U {ε})) –> 2Q
• What we want (why?): δ : (2Q x Σ*) –> 2Q
• As before, we will do this in two steps, which will be slightly different
from the book, and we will make use of the following NFA.
q0
ε
0/1
q2
1
0
q1
0
q3
ε
0
1

60
• Step #1:
Given δ: (Q x (Σ U {ε})) –> 2Q define δ#: (2Q x (Σ U {ε})) –> 2Q as
follows:
1) δ#(R, a) = δ(q, a) for all subsets R of Q, and symbols a in Σ U {ε}
• Note that:
δ#({p},a) = δ(q, a) by definition of δ#, rule #1 above
= δ(p, a)
• Hence, we can use δ for δ#
δ({q0, q1, q2}, 0) they did not.

R
q

}
{p
q

61
• Examples:
What is δ({q0 , q1, q2}, 1)?
δ({q0 , q1, q2}, 1) = δ(q0, 1) U δ(q1, 1) U δ(q2, 1)
= { } U {q0, q3} U {q2}
= {q0, q2, q3}
What is δ({q0, q1}, 0)?
δ({q0 , q1}, 0) = δ(q0, 0) U δ(q1, 0)
= {q0} U {q1, q2}
= {q0, q1, q2}

62
• Step #2:
Given δ: (2Q x (Σ U {ε})) –> 2Q define δ^: (2Q x Σ*) –> 2Q as follows:
δ^(R,w) – The set of states M could be in after processing string w,
having starting from any state in R.
Formally:
2) δ^(R, ε) = ε-closure(R) - for any subset R of Q
3) δ^(R,wa) = ε-closure(δ(δ^(R,w), a)) - for any w in Σ*, a in Σ, and
subset R of Q
• Can we use δ for δ^?

63
• Consider the following example:
δ({q0}, 0) = {q0}
δ^({q0}, 0) = ε-closure(δ(δ^({q0}, ε), 0)) By rule #3
= ε-closure(δ(ε-closure({q0}), 0)) By rule #2
= ε-closure(δ({q0, q1, q2}, 0)) By ε-closure
= ε-closure(δ(q0, 0) U δ(q1, 0) U δ(q2, 0)) By rule #1
= ε-closure({q0} U {q1, q2} U {q2})
= ε-closure({q0, q1, q2})
= ε-closure({q0}) U ε-closure({q1}) U ε-closure({q2})
= {q0, q1, q2} U {q1, q2} U {q2}
= {q0, q1, q2}
• So what is the difference?
δ(q0, 0) - Processes 0 as a single symbol, without ε transitions.
δ^(q0 , 0) - Processes 0 using as many ε transitions as are possible.

64
• Example:
δ^({q0}, 01) = ε-closure(δ(δ^({q0}, 0), 1)) By rule #3
= ε-closure(δ({q0, q1, q2}), 1) Previous slide
= ε-closure(δ(q0, 1) U δ(q1, 1) U δ(q2, 1)) By rule #1
= ε-closure({ } U {q0, q3} U {q2})
= ε-closure({q0, q2, q3})
= ε-closure({q0}) U ε-closure({q2}) U ε-closure({q3})
= {q0, q1, q2} U {q2} U {q3}
= {q0, q1, q2, q3}

65
Definitions for NFA-ε Machines
• Let M = (Q, Σ, δ,q0,F) be an NFA-ε and let w be in Σ*. Then w is
accepted by M iff δ^({q0}, w) contains at least one state in F.
• Let M = (Q, Σ, δ,q0,F) be an NFA-ε. Then the language accepted by
M is the set:
L(M) = {w | w is in Σ* and δ^({q0},w) contains at least one state in F}

66
Equivalence of NFAs and NFA-εs
• Do NFAs and NFA-ε machines accept the same class of languages?
– Is there a language L that is accepted by a NFA, but not by any NFA-ε?
– Is there a language L that is accepted by an NFA-ε, but not by any DFA?
• Observation: Every NFA is an NFA-ε.
• Therefore, if L is a regular language then there exists an NFA-ε M
such that L = L(M).
• It follows that NFA-ε machines accept all regular languages.
• But do NFA-ε machines accept more?

67
• Lemma 1: Let M be an NFA. Then there exists a NFA-ε M’ such
that L(M) = L(M’).
• Proof: Every NFA is an NFA-ε. Hence, if we let M’ = M, then it
follows that L(M’) = L(M).
The above is just a formal statement of the observation from the
previous slide.

68
• Lemma 2: Let M be an NFA-ε. Then there exists a NFA M’ such
that L(M) = L(M’).
• Proof: (sketch)
Let M = (Q, Σ, δ,q0,F) be an NFA-ε.
Define an NFA M’ = (Q, Σ, δ’,q0,F’) as:
F’ = F U {q} if ε-closure(q) contains at least one state from F
F’ = F otherwise
δ’(q, a) = δ^(q, a) - for all q in Q and a in Σ
• Notes:
– δ’: (Q x Σ) –> 2Q is a function
– M’ has the same state set, the same alphabet, and the same start state as M
– M’ has no ε transitions

69
• Example:
• Step #1:
– Same state set as M
– q0 is the starting state
q0
ε
0/1
q2
1
0
q1
0
q3
ε
0
1
q2
q1
q3
q0

70
• Example:
• Step #2:
– q0 becomes a final state
q0
ε
0/1
q2
1
0
q1
0
q3
ε
0
1
q2
q1
q3
q0

71
• Example:
• Step #3:
q0
ε
0/1
q2
1
0
q1
0
q3
ε
0
1
q2
q1
q3
q0
0
0
0

72
• Example:
• Step #4:
q0
ε
0/1
q2
1
0
q1
0
q3
ε
0
1
q2
q1
q3
q0
0/1
0/1
0/1
1

73
• Example:
• Step #5:
q0
ε
0/1
q2
1
0
q1
0
q3
ε
0
1
q2
q1
q3
q0
0/1
0/1
0/1
1
0
0

74
• Example:
• Step #6:
q0
ε
0/1
q2
1
0
q1
0
q3
ε
0
1
q2
q1
q3
q0
0/1
0/1
0/1
1
0/1
0/1
1
1

75
• Example:
• Step #7:
q0
ε
0/1
q2
1
0
q1
0
q3
ε
0
1
q2
q3
q0
0/1
0/1
0/1
1
0/1
0/1
1
1 0
q1

76
• Example:
• Step #8: [use table of e-closure]
– Done!
q0
ε
0/1
q2
1
0
q1
0
q3
ε
0
1
q2
q1
q3
q0
0/1
0/1
0/1
1
0/1
0/1
1
1 0/1

77
• Theorem: Let L be a language. Then there exists an NFA M such
that L= L(M) iff there exists an NFA-ε M’ such that L = L(M’).
• Proof:
(if) Suppose there exists an NFA-ε M’ such that L = L(M’). Then by
Lemma 2 there exists an NFA M such that L = L(M).
(only if) Suppose there exists an NFA M such that L = L(M). Then by
Lemma 1 there exists an NFA-ε M’ such that L = L(M’).
• Corollary: The NFA-ε machines define the regular languages.

FiniteAutomata (1).ppt

More Related Content

Similar to FiniteAutomata (1).ppt (20)

More from ssuser47f7f2 (10)

Recently uploaded (20)

FiniteAutomata (1).ppt