Deterministic Finite State Automata (DFA)

1
Deterministic Finite State Automata (DFA)
0 1 1 0 0

• 
  ..
• One-way, infinite tape, broken into cells
• One-way, read-only tape head.
• Finite control, 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.

Finite Control
2

• The finite control can be described by a
  transition diagram
• 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 0s

3

• 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
  cs
• Note that every state in a DFA has an implicit
  assertion

4
Formal Definition of a DFA

• A DFA is a five-tuple
• M (Q, S, d, q0, F)
• Q A finite set of states
• S A finite input alphabet
• q0 The initial/starting state, q0 is in Q
• F A set of (zero or more) final/accepting
  states, which is a subset of Q
• d A transition function, which is a total
  function from Q x S to Q
• d (Q x S) gt Q d is defined for any q in Q
  and s in S, and
• d(q,s) q is equal to another state q in
  Q.
• Intuitively, d(q,s) is the state entered by M
  after reading symbol s while in state q.

5

• For example 1
• Q q0, q1
• S 0, 1
• Start state is q0
• F q0
• d
• 0 1
• q0 q1 q0
• q1 q0 q1

6

• For example 2
• Q q0, q1, q2
• S a, b, c
• Start state is q0
• F q2
• d a b c
• q0 q0 q0 q1
• q1 q1 q1 q2
• q2 q2 q2 q2
• Since d is a function, at each step M has exactly
  one option.
• It follows that for a given string, there is
  exactly one computation.
• Since d is a total function, it is defined for
  every state q and symbol s.

7

• Give a DFA M such that
• L(M) x x is a string of (zero or more)
  as, bs and cs such
• that x contains the substring aa

8

• Give a DFA M such that
• L(M) x x is a string of (zero or more)
  as, bs and cs such
• that x does not contain the substring aa

9

• Give a DFA M such that
• L(M) x x is a string of as, bs and cs
  such that x
• contains the substring aba

10

• Questions
• How difficult would it be to simulate a specific
  DFA?
• How difficult would it be to automatically
  generate DFA simulators, i.e., Lex?
• Which of the following are valid DFAs?
• No final state
• Unreachable state
• Missing transition
• Disconnected components
• Single state

11
Extension of d to Strings

• d (Q x S) gt Q
• d(q,x) The state entered after reading string
  x having started in state q.
• Formally
• 1) d(q, e) q, and x0
• 2) For all w in S and a in S xgt1, i.e.,
  xwa
• d(q,wa) d (d(q,w), a)
• Note that this definition is for any string x in
  S, where xgt0.

12

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

13

• Note that
• d (q,a) d(d(q, e), a) by definition of
  d, rule 2
• d(q, a) by definition of d, rule 1
• More generally, it is obvious from the definition
  of d that
• d (q, a1a2an) d(d(d(d(q, a1), a2)), an)
• Hence, we can (informally) use d in place of d
• d(q, a1a2an) d(q, a1a2an)
• In other words, d doesnt really add anything to
  d.

14

• Consider the following DFA
• What is d(q0, 011)? Informally, it is the state
  entered by M after processing 011 having started
  in state q0.
• Formally
• d(q0, 011) d (d(q0,01), 1) by rule 2
• d (d (d(q0,0), 1), 1) by rule 2
• d (d (q1, 1), 1) by definition of d
• d (q1, 1) by definition of d
• q1 by definition of d
• Is 011 accepted? No, since d(q0, 011) q1 is not
  a final state.

1
1
1
0
0
q0
q1
0
15

• Recall Example 2
• What is d(q1, 10)?
• d(q1, 10) d (d(q1,1), 0) by rule 2
• d (q1, 0) by definition of d
• q2 by definition of d
• Based on the above, can we conclude that 10 is
  accepted?
• No, since d(q0, 10) q1 is not a final state.
  The fact that d(q1, 10) q2 is irrelevant!

0
0
16
Definitions for DFAs

• Let M (Q, S, d,q0,F) be a DFA and let w be in
  S. Then w is accepted by M if d(q0,w) p
  for some state p in F, i.e., d(q0,w) n F ? Ø.
• Let M (Q, S, d,q0,F) be a DFA. Then the
  language accepted by M is
• L(M) w w is in S and d(q0,w) n F ? Ø
• Other, equivalent, less formal definitions
• L(M) w w is in S and d(q0,w) is in F
• L(M) w w is in S 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, S1, d1, q0, F1) and M2 (Q2, S2,
  d2, p0, F2) be DFAs. Then M1 and M2 are
  equivalent iff L(M1) L(M2).

17

• Notes
• A DFA M (Q, S, d,q0,F) partitions the set S
  into two sets L(M) and
• S - L(M).
• In the definition of a regular language that
  means exactly equals.
• If L L(M) then L is a subset of L(M), and L(M)
  is a subset of L.
• 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
• L1 x x is a string of 0's and 1's
  containing an even number of 1's and
• L2 x x 0n1n for some n gt 0
• then L1 is regular but L2 is not.

18

• Give a DFA M such that
• L(M) x x is a string of as and bs such
  that x
• contains both aa and bb

19

• Let S 0, 1. Give DFAs for , e, S, and
  S.
• For For e
• For S For S

0,1
20
Nondeterministic Finite StateAutomata (NFA)

• An NFA is a five-tuple
• M (Q, S, d, q0, F)
• Q A finite set of states
• S 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
• d A transition function, which is a total
  function from Q x S to 2Q
• d (Q x S) gt 2Q -2Q is the power set of Q, the
  set of all subsets of Q d(q,s) -The set of all
  states p such that there is a transition
• labeled s from q to p
• d(q,s) is a function from Q x S to 2Q (but not
  to Q)

21

• Example 1
• Q q0, q1, q2
• S 0, 1
• Start state is q0
• F q2
• d 0 1
• q0
• q1
• q2
• A string is said to be accepted if there exists a
  path to some state in F that uses all the symbols
  in the string (try 0010 or 0110).
• This NFA accepts the set of all strings of 0s
  and 1s that start with one or more 0s, followed
  by one or more 1s, followed by any sequence of
  0s and 1s.
• Could this language be accepted by a DFA
  (exercise)?

0,1
0
1
0
1
q0
q1
q0, q1
q1, q2
q2 q2
22

• Example 2
• Q q0, q1, q2 , q3 , q4
• S 0, 1
• Start state is q0
• F q2, q4
• d 0 1
• q0
• q1
• q2
• q3
• q4

1
q0, q3 q0, q1
q2
q2 q2
q4
q4 q4
23

• Notes
• d(q,s) may not be defined for some q and s
  (why?).
• Informally, a string is said to be accepted if
  there exists a path to some state in F that uses
  up all the input symbols in the string.
• 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?
• Doesnt matter
• NFAs are a non-intuitive computing model.
• Regardless, the notions of string and language
  acceptance are well-defined.
• We are primarily interested in NFAs as language
  defining devices, i.e., do NFAs accept languages
  that DFAs do not?
• Other questions are secondary, including
  practical questions such as whether or not there
  is an algorithm for finding an accepting path
  through an NFA for a given string,

24

• However, 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

25

• Another example (010)
• q0 q0 q0 q0
• q3 q1 q3
• not accepted
• All paths have been explored, and none lead to an
  accepting state.
• How difficult would it be to simulate an NFA?

26

• Let S a, b, c. Give an NFA M that accepts
• L x x is in S and x contains ab
• Is L a subset of L(M)?
• Is L(M) a subset of L?
• Is an NFA necessary? Could a DFA accept L? Try
  and give an equivalent DFA as an exercise.
• Designing NFAs is not a typical task.

27

• Let S a, b. Give an NFA M that accepts
• L x x is in S 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?
• What if q3 had a transition to itself on a or b?
• Give an equivalent DFA as an exercise.

28
Extension of d to Strings

• What we currently have d (Q x S) gt 2Q
• What we want (why?) d (Q x S) gt 2Q
• d(q,x) The set of states the NFA could be in
  after reading string x having started in state
  q.
• Formally
• 1) d(q, e) q, and x0
• 2) For all w in S and a in S, xgt1, i.e.,
  xwa
• if d(q, w) p1, p2,, pk, and
• d(pi, a) r1, r2,, rm then d(q,wa)
  r1, r2,, rm

29

• Example
• What is d(q0, 01)?
• Informally The set of states the NFA could be
  in after processing 01, i.e., q2, q3
• Formally
• 1) d (q0, e) q0

30

• Note that just like with DFAs, we could prove
  that we can use d in place of d, i.e.,
• d(q, a1a2an) d(q, a1a2an)

31
Definitions for NFAs

• Let M (Q, S, d,q0,F) be an NFA and let w be in
  S. Then w is accepted by M iff d(q0, w)
  contains at least one state in F, i.e.,
  d(q0,w) n F ? Ø.
• Let M (Q, S, d,q0,F) be an NFA. Then the
  language accepted by M is the set
• L(M) w w is in S and d(q0,w) n F ? Ø
• Other, equivalent, less formal definitions
• L(M) w w is in S and d(q0,w) contains at
  least one state in F
• L(M) w w is in S and w is accepted by M

32
Equivalence of DFAs and NFAs

• Do DFAs and NFAs accept the same class of
  languages?
• Do they accept different classes 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?
• Perhaps they accept overlapping classes of
  languages.
• In other words, is one of these two machine
  models more powerful than the other?

33

• Observation Every DFA is an NFA.
• Consider the following DFA
• Q q0, q1, q2
• S a, b, c
• Start state is q0
• F q2
• d a b c
• q0 q0 q0 q1
• q1 q1 q1 q2
• q2 q2 q2 q2

34

• An Equivalent NFA
• Q q0, q1, q2
• S a, b, c
• Start state is q0
• F q2
• d a b c
• q0 q0 q0 q1
• q1 q1 q1 q2
• q2 q2 q2 q2

35

• Therefore, if L is a regular language then there
  exists an NFA M such that L L(M).
• Thus, NFAs accept all regular languages, i.e.,
  NFAs are at least as powerful as DFAs.
• Stated formally
• 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).
• So NFAs accept the regular languages, but do they
  accept more?

36

• Lemma 2 Let M be an NFA. Then there exists a
  DFA M such that L(M) L(M).
• Proof (sketch)
• Let M (Q, S, d,q0,F).
• Define a DFA M (Q, S, d,q0,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
• q0 q0
• d(Qu, a) d(p, a)

37

• Example
• Q q0, q1
• S 0, 1
• Start state is q0
• F q0
• d 0 1
• q0
• q1

0,1
0
q1
0
q1
q0, q1 q1
38

• Construct DFA M as follows
• d(q0, 0) q1 gt d(q0, 0) q1
• d(q0, 1) gt d(q0, 1)
• d(q1, 0) q0, q1 gt d(q1, 0) q0, q1
• d(q1, 1) q1 gt d(q1, 1) q1
• d(q0, 0) U d(q1, 0) q0, q1 gt d(q0, q1, 0)
  q0, q1

1
0,1
1
0

q1
0
1
0
39

• So why does this construction work?
• Consider a simulation of the original NFA on the
  string 0010
• Consider a simulation of the resulting DFA on the
  same string
• Finally, note the constructive nature of the
  proof, i.e., it shows how to construct the DFA
  (not all proofs are constructive).
• In fact, the construction could be programmed
• As an exercise, try the construction on some of
  the NFAs from class.

40

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

41

• Note Suppose R
• d(R, 0) d(q, 0)
• Since R
• Exercise - Convert the following NFA to a DFA
• Q q0, q1, q2 d 0 1
• S 0, 1
• Start state is q0 q0
• F q0
• q1
• q2

q0, q1
q1 q2
q2 q2
42
NFAs with e Moves

• An NFA-e is a five-tuple
• M (Q, S, d, q0, F)
• Q A finite set of states
• S 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
• d A transition function, which is a total
  function from Q x (S U e) to 2Q
• d (Q x (S U e)) gt 2Q
• d(q,s) -The set of all states p such that
  there is a
• transition labeled a from q to p, where a
• is in S U e
• Sometimes referred to as an NFA-e other times,
  simply as an NFA.

43

• Example
• d 0 1 e
• q0 - A string w w1w2wn is processed
• as w ew1ew2e ewne
• q1 - Example all computations on 00
• 0 e 0
• q2 q0 q0 q1 q2
• q3

q0 q1
q1, q2 q0, q3 q2
q2 q2

44

• Example 2
• What language does the above NFA-e accept?

0
1
e
q1
q2
e
e
q5
q0
1
0
e
e
e
q3
q4
45

• Example 3

e
1
1
q0
q1
0
e
46
Informal Definitions

• Let M (Q, S, d,q0,F) be an NFA-e.
• A String w in S 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 e transitions.
• The language accepted by M is the set of all
  strings from S that are accepted by M.
• Formalizing these concepts is more difficult than
  it was for DFAs and NFAs.

47
e-closure

• Define e-closure(q) to denote the set of all
  states reachable from q by zero or more e
  transitions.
• Examples (for example 1)
• e-closure(q0) q0, q1, q2 e-closure(q2)
  q2
• e-closure(q1) q1, q2 e-closure(q3) q3
• Formal (recursive) Definition
• For any state q
• 1) q ? e-closure(q)
• 2) if p ? e-closure(q) and r ? d(p, e) then r ?
  e-closure(q)

48
Extension of d to Strings

• What we currently have d (Q x (S U e)) gt 2Q
• What we want (why?) d (Q x S) gt 2Q
• d(q,x) The set of states the NFA-e could be in
  after reading string x having started in state
  q.
• Formally
• 1) d(q, e) e-closure(q), and x 0
• 2) For all w in S and a in S, x gt 1, i.e.,
  xwa
• if d(q, w) p1, p2,, pk, and d(pi, a)
  r1, r2,, rm
• then d(q,wa) e-closure(ri)

49

• Note the difference between
• d(q0, 0) q0
• d(q0, 0) q0, q1, q2
• So, unlike with DFAs and NFAs, we cant
  substitute d for d.
• See the book for a sample derivation.

50
Definitions for NFA-e Machines

• Let M (Q, S, d,q0,F) be an NFA-e and let w be
  in S. Then w is accepted by M iff d(q0, w)
  contains at least one state in F.
• Let M (Q, S, d,q0,F) be an NFA-e. Then the
  language accepted by M is the set
• L(M) w w is in S and d (q0,w) n F ? Ø
• Other equivalent, less formal, definitions
• L(M) w w is in S and d(q0,w) contains at
  least one state in F L(M) w w is in S and
  w is accepted by M

51
Equivalence of NFAs and NFA-es

• Do NFAs and NFA-e machines accept the same class
  of languages?
• Do they accept different classes of languages?
• Is there a language L that is accepted by a NFA,
  but not by any NFA-e?
• Is there a language L that is accepted by an
  NFA-e, but not by any NFA?
• Perhaps they accept overlapping classes of
  languages.
• In other words, is one of these two machine
  models more powerful than the other?

52

• Observation Every NFA is an NFA-e.
• Therefore, if L is a regular language then there
  exists an NFA-e M such that L L(M).
• It follows that NFA-e machines accept all regular
  languages.
• Stated formally
• Lemma 1 Let M be an NFA. Then there exists a
  NFA-e M such that L(M) L(M).
• Proof Every NFA is an NFA-e. Hence, if we let
  M M, then it follows that L(M) L(M).
• But do NFA-e machines accept more?

53

• Example (NFA)
• Q q0, q1
• S 0, 1
• Start state is q0
• F q0
• d 0 1
• q0
• q1

0,1
0
q1
0
q1
q0, q1 q1
54

• Example NFA-e
• Q q0, q1
• S 0, 1
• Start state is q0
• F q0
• d 0 1 e
• q0
• q1

0,1
0
q1
0
q1
q0, q1 q1
55

• Lemma 2 Let M be an NFA-e. Then there exists
  a NFA M such that L(M) L(M).
• Proof (sketch)
• Let M (Q, S, d,q0,F) be an NFA-e.
• Define an NFA M (Q, S, d,q0,F) as
• F F U q0 if e-closure(q0) contains at
  least one state from F
• F F otherwise
• d(q, a) d(q, a) - for all q in Q and a in
  S
• Notes
• d (Q x S) gt 2Q is a function
• M has the same state set, the same alphabet, and
  the same start state as M
• M has no e transitions

56

• Example
• Step 1
• Same state set as M
• q0 is the starting state

57

• Example
• Step 2
• q0 becomes a final state

q3
q1
58

• Example
• Step 3

q3
1
0,1
0
0
e
e
q0
q1
0
1
q3
0
0
q1
0
59

• Example
• Step 4

q3
1
0,1
0
0
e
e
q0
q1
0
1
q3
1
0,1
0,1
q1
0,1
60

• Example
• Step 5

q3
1
0,1
0
0
e
e
q0
q1
0
1
q3
1
0,1
0
0
0,1
q1
0,1
61

• Example
• Step 6

q3
1
0,1
0
0
e
e
q0
q1
0
1
q3
1
0,1
1
0,1
0,1
0,1
q1
1
0,1
62

• Example
• Step 7

q3
1
0,1
0
0
e
e
q0
q1
0
1
q3
1
0,1
1
0
0,1
0,1
0,1
q1
1
0,1
63

• Example
• Step 8
• Done!

q3
1
0,1
0
0
e
e
q0
q1
0
1
q3
1
0,1
1
0,1
0,1
0,1
0,1
q1
1
0,1
64

• Theorem Let L be a language. Then there
  exists an NFA M such that L L(M) iff there
  exists an NFA-e M such that L L(M).
• Proof
• (if) Suppose there exists an NFA-e 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-e M such that L L(M).
• Corollary The NFA-e machines define the regular
  languages.

65

• Theorem Let L be a language. Then there
  exists an NFA M such that L L(M) iff there
  exists an NFA-e M such that L L(M).
• Proof
• (if) Suppose there exists an NFA-e 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-e M such that L L(M).
• Corollary The NFA-e machines define the regular
  languages.

66

• Finally, once again note the constructive nature
  of the proof, i.e., it shows how to construct the
  NFA.
• In fact, the construction could be programmed

67

• Give a DFA M such that
• L(M) x x is a string of 0s and 1s and
  x gt 2