60-354, Theory of Computation

Fall 2013
Asish Mukhopadhyay
School of Computer Science
University of Windsor
 Formal Definition of a DFA
• A DFA is a 5-tuple : (Q, ∑, δ, q0, F)
– Q is the set of states
– ∑ is the input alphabet
– δ is the transition function
• δ : Q X ∑ -> Q
– F , a subset of Q, is the set of final states
 Example
• Q = {q0, q1}
• ∑ = {0,1}
• F = {q0}
Extended transition function

ˆ
 (q, e)  q
ˆ(q, aw)  ˆ( (q, a), w)
Transition function Example

ˆ(q0 ,001)  ˆ( (q0 ,0),01)

 ˆ (q1 ,01)
 ˆ ( (q ,0),1)
1

 ˆ (q0 ,1)
 ˆ ( (q ,1),  )
0

 ˆ (q0 ,  )
 q0
 Language accepted by a DFA
• L = { w in ∑* |ˆ (q0, w) is an accepting state of
A}
 Regular Language
• Language accepted by a DFA
 DFA Constructions
• Example 2
– Construct a DFA that accepts all strings over {0,1}
such that the reverse of w, when evaluated in
decimal, is divisible by 5 (or, multiple of 5)
 Reverse of a string
• If w =x1x2..xk is a string, then wr = xkxk-1,…,x1
• Thus if w = 1101, wr = 1011
 Main Observation
• The contribution , modulo 5, of a current 1 bit
is periodic with respect to its position from
the left.
• That’s because:
– 20 mod 5 = 1 24 mod 5 = 1
– 21 mod 5 = 2 25 mod 5 = 2 ……….
– 22 mod 5 = 4 26 mod 5 = 4
– 23 mod 5 = 3 27 mod 5 = 3
 State description
• q i,j
– i is the current position in the string modulo 4
– j is the cumulative reminder modulo 5 of the
string seen so far
 Transition function
• δ(qi,j, 0) = q(i+1) mod 4, j
• δ(qi,j, 1) = q(i+1) mod 4, (j +2(i+1) mod 4) mod 5
• Start state : q-1,0
 DFA constructions
• Example 3
– The set of all strings such that each block of five
consecutive symbols contains at least two 0’s.
 Solution
• Build a DFA, maintaining 2 pieces of
information
– The decimal value of the current block of 5 bits
– The number of 0’s in it
• Updating the decimal value as we move one
place right:
– (oldValue * 2) mod 32 + decimal value of the new
bit (this value tells us whether the leading bit of
the block of 5 bits is a 1 or a 0)
DFA for modified Example 3
Example 4
Example 4
 Product automaton
• Let DFA Ai = (Qi, ∑, δi, qi0, Fi), for i = 1, 2,
recognize language Li over ∑.
• Then the automaton
– A1 X A2 = (Q1 X Q2, ∑, δ, (q01, q02 ), F1 X F2), where
δ((q1i ,q2j), a) = (δ1(q1i , a), δ2 (q2j, a)), for all a in ∑
is called the product automaton of A1 and A2
• The language accepted by A1 X A2 is the set of
all strings in L1  L2
 Solving the last problem
• Now use the idea of a product automaton to
construct an automaton with 12 states that
accepts all strings the begin with and end in
01.
A DFA accepting strings beginning with
01 or ending in 01
 Nondeterministic Finite Automata
• NFA, for short
• Allow transitions from a given state on a given
input to any one of a finite number of states
or no state at all
 Problem
• Construct an automaton that accepts all
strings over ∑ = {0, 1} such that the tenth
(10th) symbol from the right end is a 1
Example 5
 Designing a DFA
• Not straightforward
• Simpler problem
– Construct a DFA that accepts strings whose
second digit from the right is a 1
 Solution
• Compute modulo 4 the decimal value of the
string seen thus far
• If the value is 2 or 3 when we come to the end
of the string the second bit from the right is 1
• Update value as we advance one place right:
– Multiply previous value by 2, add the current bit
and compute the result modulo 4
 Transition table

The index j of qj is the remainder modulo 4

 Formal definition of an NFA
• A 5-tuple (Q, ∑, δ, q0, F) where

 :Q   2 Q
Extended transition function

ˆ(q,  )  {q}
ˆ(q, wa)  r  (r , a), where r  ˆ(q, w)
 Language accepted by NFA
• L = {w in ∑* |ˆ (q0, w) intersection F is not
empty}
 NFA to DFA reduction
• Subset construction technique
– The states of the DFA are all possible subsets of
the states of the NFA
– The start state is: {q0}
– Final states:
• All subsets that contain at least one of the accepting
states of the NFA
Construction by example (1)
 Construction by example (2)
• If δD() is the transition function of the DFA,
and S is a subset of the states of the NFA then

 D (S , a)  q  N (q, a), q  S
Equivalent DFA
Transition table
 Proof sketch (1)
• Let L1 be the language accepted by the given
NFA
• Let L2 be the language accepted by the
constructed DFA
• We show L1 = L2
• For this we show that ˆD ({q0},w) is an
accepting state iff ˆN (q0,w) contains an
accepting state of the given NFA.
 Proof sketch (2)
• We establish the stronger fact

ˆD ({q0 }, w)  ˆN (q0 , w) for an arbitrary string w in *

 Proof sketch (3)
• Induction on |w|
• Basis step: w = ε

ˆD ({q0 },  )  ˆN (q0 ,  )  {q0 }

• Inductive hypothesis

ˆD ({q0 }, w)  ˆN (q0 , w)  S

for some |w| ≥ 0
 Formal proof (4)
For a string wa :
 Formal proof (5)
• Class of languages accepted by NFAs is
contained in the class of languages accepted
by DFAs
• Conversely, as every DFA is trivially an NFA the
class of languages accepted by DFAs is
contained in the class of languages accepted
by NFAs
 ε-NFA
• Allow transitions on ε
• Include ε in the alphabet ∑
Example
 A new definition
• The ε-closure of a state q, ECLOSE(q), is the set
of all states reachable from q by a finite
number of transitions
• Thus, ECLOSE(q0) = {q0, q1, q2}
• For a set of states S:
ECLOSE(S )  q ECLOSE(q), q S
 Extended transition function

ˆNE (q,  )  ECLOSE({q})

ˆNE (q, wa)  ECLOSE(r  NE (r , a)), where r  ˆNE (q, w)
 ε-NFA to DFA
• Same as the reduction: NFA to DFA
• With one additional step:

 D (S , a)  ECLOSE( r  NE (r , a)), where r S

 Example ε-NFA
 D ({q0 , q1 , q2 }, a)  {q0 , q1 , q2 }
 D ({q0 , q1 , q2 }, b)  {q1 , q2 }
 D ({q0 , q1 , q2 }, c)  {q2 }
 D ({q1 , q2 }, a)   (dead state)
 D ({q1 , q2 }, b)  {q1 , q2 }
 D ({q1 , q2 }, c)  {q2 }
 D ({q2 }, a)  
 D ({q2 }, b)  
 D ({q2 }, c)  {q2 }
 Equivalence proof for any ε-NFA
• Set qD = ECLOSE(q0)
• Prove by induction for an arbitrary string w
that:

ˆD (qD , w)  ˆNE (q0 , w)  S

 Equivalence proof…..
• Base case: w = ε

ˆD (qD ,  )  ˆNE (q0 ,  )  ECLOSE(q0 )

 Equivalence proof…..
• Assume inductively

ˆD (qD , w)  ˆNE (q0 , w)  S for some | w |  0

 Equivalence proof…..
• Then

Thus a string is accepted by the constructed DFA iff it

is accepted by the ε-NFA
 What we have shown…
• The class of languages accepted by DFAs is in
the class of languages accepted by ε-NFAs
• Now to show the converse ….
 Regular expressions
• Definition
– a, ε, φ are regular expressions (a in ∑)
– If r and s are regular expressions then so are r+s,
r*s (usually written rs) and r*
– r* = ε + r + r2+ r3+….
Languages and regular expressions
• There is a language corresponding to every
regular expression
• {a}, {ε}, φ for a, ε and φ respectively
• If L(r) and L(s) are the languages
corresponding to r and s then L(r) UL(s),
L(r)L(s) and (L(r))* are languages
corresponding to the regular expressions r+s,
rs and r*
 Constructing re’s …
• Construct a regular expression for the set of
all strings over ∑ = {0,1}
• ε is the re for the empty string ε
• (0+1) for the strings 0 and 1 of length 1
• (0+1)(0+1) for all the strings of length 2
• ….
• Thus: (0+1)* = ε + (0+1) + (0+1)2 + (0+1)3 +….
 More examples (1)
• Construct a regular expression from the
following description: the language consisting
of all strings of 0’s and 1’s whose tenth symbol
from the right end is 1.
 Solution
• (0+1)*1(0+1)9
 More examples (2)
• Construct a regular expression from the
following description: the language consisting
of all strings of 0’s and 1’s whose number of
0’s is divisible by 5.
 Solution
• Think backwards!
• Remove all 1’s and block the 0’s in groups of 5
• Reinsert the 1’s
• The internal structure of a block of string with
exactly five 0’s is: 01*01*01*01*0
• These blocks are separated by zero or more 1’s
• Thus the r.e.: (1 + 01*01*01*01*0)*
 The other way round
• Give an English language description of the
language corresponding to the following
regular expression: (0 + 10)*1*
 Solution
• Any string s in L((0 + 10)*1*) can be written as αβ,
where
– α = ε or α ε L((0 + 10)*) and
– β = ε or β ε L(1*).
• When α = ε or β = ε, s cannot have 110 as a substring;
• Otherwise, consider
– a substring a1a2a3 of length 3 that spans both α and β.
– If a1a2 is a suffix of α, a1a2 = 10|00; and a3 = 1.
– Hence a1a2a3 ≠ 110.
– If a2a3 is a prefix of , then a2a3 = 11 and a1 = 0.
– Hence a1a2a3 ≠110.
– This covers all the cases and hence the claim.
 Regular expressions from a DFA
• Idea:
– find a regular expression label for all paths from
the start state to an accepting state, by
eliminating all other states except these two
– If the start state is also accepting, we determine
this regular expression by eliminating all states
except the start state
– The regular expression corresponding to the
language accepted by the DFA is the “sum” of all
the regular expressions so obtained.
 State Elimination
• If we remove the state q, the transition from the state p to
the state r has to be labelled by the regular expression
b + ab*a
Case 1
Case 2
Example DFA for state elimination
Removing state s
Reduced DFA
Removing state q
 Reduced DFA

Reduced DFA on elimination of state q

Removing state r
Regular expressions to ε-NFAs
Regular expressions to ε-NFAs

ε-NFA for RS
Regular expressions to ε-NFAs

ε-NFA for R+S

Regular expressions to ε-NFAs

ε-NFA for R*
 Example
• Construct ε-NFA that accepts L((0 +10)*1*))
ε-NFA for L((0 +10)*1*))
ε-NFA for L((0 +10)*1*))
 Summing up (1)
• With this we have completed the sequence of
reductions
 Summing up (2)
• This establishes the equivalence of all the
computational models in that they all
recognize the class of regular languages