Tutorial 02

-- CSC3130 : Formal Languages

and Automata Theory
Tu Shikui (sktu@cse.cuhk.edu.hk)
SHB 905, Office hour: Thursday 2:30pm-3:30pm
2008-09-12

Outline
From NFA to NFA
From DFA to RE
Closed operators for Regular Languages

From NFA to NFA

-transitions

is the empty string, it contains no alphabets;

It makes a state transition when seeing .
It makes a state transition without receiving an input
symbol (from alphabet);
It makes a state transition unconditionally;

NFA

NFA + Allows -transitions;

It brings programming convenience;
Closely related to regular expressions

From NFA to NFA

-- an example from Lecture notes (1/8)
NFA:

NFA:

q0

,b
a

q0

a a, b
a

q1

q1
a, b

q2

q2

From NFA to NFA

-- an example from Lecture notes (2/8)
NFA:

q0

,b
a

q1

q2

(1) States stay the same

(2) Start

NFA:

q0

state
q1

stays the same

q2

From NFA to NFA

-- an example from Lecture notes (3/8)
NFA:
Path in NFA:

,b
a

q0

qi

qk
qi

Equivalent Path in NFA:

q1

a q
m

q2

a q
j

?
NFA:

q0

q1
?

q2

qj

From NFA to NFA

-- an example from Lecture notes (4/8)
NFA:
Path in NFA:

,b
a

q0

q0

q1

q1
a

q0

Equivalent Path in NFA:

q2

q0
q0

a
NFA:

q0

q1
?

q2

From NFA to NFA

-- an example from Lecture notes (5/8)
NFA:
Path in NFA:

,b
a

q0

q0

Equivalent Path in NFA:

NFA:

q0

q1
q0

q1
a
a

a a, b

q2

q1

q0

q1

q1

q0

q1

q1
?

q2

From NFA to NFA

-- an example from Lecture notes (6/8)
NFA:
Path in NFA:

,b
a

q0

q0

Equivalent Path in NFA:

NFA:

q0

q1

q1 a q1 q2
q0

a a, b

q2

q1
a, b

q2
q0 b q1 q2
b

q0

q2

q2

From NFA to NFA

-- an example from Lecture notes (7/8)
NFA:

NFA:

q0

,b
a

q0

a a, b
a

q1

q1
a, b

q2

q2

From NFA to NFA

-- an example from Lecture notes (8/8)
NFA:

q0

,b
a

q1

q2

(4) The accepting states of the NFA are all states that can reach
some accepting state of NFA using only -transitions

NFA:

q0

a a, b
a

q1
a, b

q2

Outline
From NFA to NFA
From DFA to RE
Closed operators for Regular Languages

From DFA to RE
-- General construction
We inductively define Rijk as:
Rii0 = ai1 + ai2 + + ait +
(all loops around qi
and )

Rij0 = ai + ai + + ai
1

(all qi qj)

qi

if i j
qi

ai1,ai2,,ait
ai1,ai2,,ait

qj

Rijk = Rijk-1 + Rikk-1(Rkkk-1)*Rkjk-1

(for k > 0)

qk
qi

a path in M qj

From DFA to RE
-- an example (1/3)
1

q
1

q2

R110 = {, 1} = 1
+

R120 = {0} = 0
R21 = {0} = 0

q2

q2

q
0

1
q2

R
From DFA to RE
-- an example (2/3)
1

q1

0
0

ij

= Rijk-1 + Rikk-1(Rkkk-1)*Rkj

1
q2

R110 = {, 1} = 1 + ;
R120 = {0} R111 = {, 1, 11,
111, ...}
=0
= 1*
10
0
01
0
R
=
R
+
R
= {0} = 0;
R2222 = {,
R21
22
12 = R12 +
R210(R110)*R120
1}
1 11
+0)*R
120
R11=0(R
1
1
1
R122=
=0R+
+ R12)1+(R
12 (1+
0 22 )*R22 = (1 + ) + 0(1+
)*+
0 (1+ )+0) ((1 + ) +
= (0 + (1+ )+0) + (0
0(1+ )*0)+
= (0 + (1+ )+0) ((1 + ) + 0(1+ )*0)*
= (1+ )*0 ((1 + ) + 01*0)*

From DFA to RE (3/3)

-- Determine the accepted RE for DFA
Suppose the DFA start state is q1, and the

accepting states are F = {qj1 qj2 qjt}

Then the regular expression for this DFA is

R1j1n + R1j2n + .. +
1
q1

R1jtn
0
0

1
q2

R122=1*0
(1+01*0)*

Outline
From NFA to NFA
From DFA to RE
Closed operators for Regular Languages

Closed operators for Regular Languages

-- An Exercise
Prove or disprove the regular languages are

closed under the following operations:

(1). min(L) = { w | w is in L, but no proper
prefix of w is in L };
(2). max(L) = { w | w is in L and for no x other
than is wx in L };
(3). init(L) = { w | for some x, wx is in L }

Hint: Start with a DFA for L and perform a construction to

get the desired language.

(1). min(L) = { w | w is in L, but no

proper prefix of w is in L };
What is proper prefix?

For example, suppose the alphabet is { 0, 1 }, then:

(1) 011, 01 are proper prefixes of 0110001;
(2) 0110001 is a prefix of 0110001, but not a
proper prefix;
(3) (i.e., ) is not a proper prefix of 0110001.

(1). min(L) = { w | w is in L, but no

proper prefix of w is in L };
What does min(L) look like?
Example(1). L = { 00, 001, 0011, 101 };
min(L) = ?

{ 00, 001, 0011, 101 }

0

Main idea:

Example(2).

n,m = 0,1,2,

L = { a, a(bc)n, baa, cbma }; min(L)

=?

w=ux

A DFA for L:

qj

qk

Cut the transitions going out of

each accepting state.

Solution for (1)

min(L) = { w | w is in L, but no proper prefix of w is in L };

Solution for (1) -- (cont.)

min(L) = { w | w is in L, but no proper prefix of w is in L };

Properties of Regular Languages

-- An Exercise
Prove or disprove the regular languages are

closed under the following operations:

(1). min(L) = { w | w is in L, but no proper
prefix of w is in L };
(2). max(L) = { w | w is in L and for no x other
than is wx in L };
(3). init(L) = { w | for some x, wx is in L }

Hint: Start with a DFA for L and perform a construction to

get the desired language.
Left as exercises at home!

End of this tutorial!

Thanks for coming!