CS5371 Theory of Computation: Lecture 5: Automata Theory III (Non-Regular Language, Pumping Lemma, Regular Expression)

CS5371
Theory of Computation
Lecture 5: Automata Theory III
(Non-regular Language, Pumping
Lemma, Regular Expression)
Objectives
•Prove the Pumping Lemma, and use it
to show that there are non-regular
languages
•Introduce Regular Expression
–which is one way to describe a language
(or a set of strings)
Non-Regular Language?
•To understand the power of DFA, apart
from knowing what it can do, we need to
know what it cannot do
•Let’s look at the language B = {0n1n | n 0}
•If we try to find a DFA to recognize B, the
DFA needs to keep track of the number of
0’s we have seen so far
•However, number of 0’ s is unlimited…there
are unlimited number of possibilities
•So, it is NOT POSSIBLE because the DFA
just has FINITE number of states!
Pumping Lemma
Theorem: If A is a regular language,
then there is a number p (called the
pumping length) such that:
if s is a string in A of length at least p, then
s can be divided into three pieces, s = xyz,
satisfying the following three conditions:
–For each k 0, xykz 2 A
–|y| 0, and
–|xy| · p
Pumping Lemma (Proof)
•Let us assign the pumping length p to be
the number of states in the DFA that
recognize A
•Consider the sequence of states that the
DFA goes through when reading
s = s1s2…sn
•At the beginning, it is at state r0 = qstart
•Then, it goes to r1 after reading s1, then
goes to r2, then goes to r3 …
Pumping Lemma (Proof)
•When it has finished reading sp, one of the
state has been visited at least two times (why?)
•That is, ri = rj , for some 0 i j p
•Now, let x = s1s2…si,
y = si+1si+2…sj, and
z = sj+1sj+2…sn
•We can check that xykz 2 A for all k 0
(why?)
•Also, |y| 0 and |xy| p (why?)
Use of Pumping Lemma
(Example 1)
•Lemma: The language B = {0n1n | n 0}

is not regular.
•How to prove?
–Use Pumping Lemma
–By contradiction
•Proof: Assume that B is regular. Then…
(Example 1)
•Then, let p be the pumping length
•We know that 0p1p is in B
•By pumping lemma, we know that 0p1p can be
divided into three parts, xyz, such that |y|
0, |xy| p, and xykz is in B for all k 0
•In this case, y consists of all 0’
s and at
least 1 zero (why??)
•xyyz is in B, but xyyz has more 0’ s than 1’
s
•Contradiction occurs!
(Example 2)
•Lemma: The language C = { w | w has

an equal number of 0s and 1s } is not
regular.
•How to prove?
(Example 2)
•Proof 1: Similar to Example 1. Let s =
0p1p and apply pumping lemma.
•Proof 2: We use the fact: the class
of regular languages is closed under
intersection (will be proved in tutorial
next Tue). That is,
If A and B are regular languages,
then A \ B is also a regular language.
(Example 2: Proof 2)
•Let A = { 0m1n | m, n ¸ 0}
•Note that A is regular (why?)
•Now, assume that C is regular. Then, it

implies that C \ A is regular
•However, C \ A = { 0n1n | n ¸ 0}, which is
not regular
•Thus, contradiction occurs (where?). So,
C is not regular
(Example 2)
•In Proof 1, we choose s = 0p1p, we can apply
pumping lemma successfully and prove that
C is not regular
•However, if we ‘ unluckily’choose s = (01)p,
using pumping lemma may not give
contradiction… (E.g., |x| =  , y = 01, z =
(01)p-1, then every xykz is in C)
•So, if you fail on first attempt, don’ t give
up, try another one!
(Example 3)
•Lemma: The language F = { ww | w 2

{0,1}* } is not regular.
•How to prove?
(Example 4)
2
•Lemma: The language {1n | n ¸ 0} is
not regular.
•Proof:
–Let p be the pumping length.
2
–Let s = 1p .
–By pumping lemma, we have |xyz| = p2.
Also, 0 |y| |xy| p.
–p2 |xyyz|  p2 + p (p+1)2
–Contradiction occurs (where??)
(Example 5)
•Lemma: The language E = { 0i1j | i j }
is not regular.
•Proof: Let s = 0p+11p. By pumping lemma,

we can divide s into xyz such that y
consists of all 0’
s and |y| 0.
•Then, xz 2 E but xz does not have more
0s than 1s
•Contradiction occurs
Regular Expression
•In arithmetic, we can use the operations
+ and x to build up expressions, such as
(5+3) x 4
–The value of this expression is 32
•Similarly, we can use regular operations
to build up regular expressions, such as
(0 [ 1)0*
–The value of this expression is a set of
strings (or a language)
What does (0 [ 1)0* mean?
•The symbols 0 and 1 are shorthand for the
set {0} and {1}
–So, (0 [ 1) means ( {0} [ {1} )
–0* means {0}*, whose value is the language
consisting of all strings with any number of 0s
•Just like x in arithmetic expression, the
concatenation symbol o is often omitted
–So, ( 0 [ 1 ) 0* means ( 0 [ 1 ) o 0*
•This expression describes the set of
strings that start with a 0 or a 1, which is
followed by any number of 0s
What does the following
regular expressions mean?
• 0*10* Binary strings containing exactly one 1
• *1* Any strings containing 1
• *001* Any strings containing 001
• 1*(01+)* Binary strings with 1 following each 0
• ()* Any strings with even length
•(0 [ ) 1* 01* [ 1*
• 1* ; Empty set (no strings)
Note: The notation R+ means RR*

Next time
•Formally define regular expression
•We will also show that
–(1) Language recognized by DFA can be
described by Regular Expression
–(2) Language described by Regular
Expression can be recognized by DFA

CS5371 Theory of Computation: Lecture 5: Automata Theory III (Non-Regular Language, Pumping Lemma, Regular Expression)

Uploaded by

Copyright:

Available Formats

CS5371 Theory of Computation: Lecture 5: Automata Theory III (Non-Regular Language, Pumping Lemma, Regular Expression)

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

CS5371 Theory of Computation: Lecture 5: Automata Theory III (Non-Regular Language, Pumping Lemma, Regular Expression)

Uploaded by

Copyright:

Available Formats

CS5371

•Lemma: The language B = {0n1n | n 0}

•Lemma: The language C = { w | w has

•Now, assume that C is regular. Then, it

•Lemma: The language F = { ww | w 2

•Proof: Let s = 0p+11p. By pumping lemma,

Note: The notation R+ means RR*

You might also like