hop-chap4.ppt

Properties of Regular Languages
CS 351

Proving Languages Not Regular
• Before we show how languages can be
proven not regular, first, how would we
show a language is regular?
• Regular languages and automata seem
powerful – after all they model everything
we have seen so far!
– But there are many simple examples that are
not regular languages

The Pumping Lemma
• Our strategy for proving languages to be non-
regular:
– The Pumping Lemma states that all regular languages
have a special property
• If we can show that a language does not have this property,
then the language cannot be regular.
• The property states that all strings in a regular language can be
“pumped” if they are at least as long as a special value, the
pumping length.
• This means that each such string contains a section that can be
repeated any number of times with the resulting string
remaining in the language.

The Pumping Lemma
• Let L be a regular language. Then there is a
number p (the pumping length) where, if s is
any string in L of length at least p, then s may be
divided into three parts, s=xyz, satisfying the
following conditions:
1. y ε (but x and z may be ε)
2. |xy|  p
3. for each k  0, xykz  L

Pumping Lemma Explanation
• This theorem says:
– when s is divided into xyz, either x or z may be empty,
but y may not be empty.
– x and y together must have length at most p.
– we can always find a nonempty string y not too far
from the beginning of s that can be “pumped”, i.e. it
can repeat any number of times.
• Note that although yε, for the third condition, k
may equal zero, giving us y0=ε, and then xz must
be  L.

Pumping Lemma Proof
• First, consider a simple case of a regular language L
– In this language there are no strings of length at least p
– In this case, the theorem becomes vacuously true.
• The three conditions hold for all strings of length at least p if
there aren’t any such strings.
• For example, if L is composed of simply the finite set { a }, then
we could pick p=2 and the theorem is vacuously true because
there are no strings of length at least 2.
– This implies for any finite set of strings, the language is regular
since we can pick a value p larger than the biggest string in L

Pumping Lemma
• More general case:
– Suppose that L is regular. Then L=L(A) for some
DFAA.
– Suppose that A has n states.
– Consider any string s of length n or more; say
s=a1a2…am where m  n.
• For i=0,1,…n, define state pi to be δ^(q0, a1a2…ai). That
is, pi is the state that A is in after reading the first i
symbols of s.
• By the pigeonhole principle, since there are more input
symbols then there are states, we must repeat some state
more than once!

More Pumping Lemma
• We must repeat some state more than once
– Thus we can find two different integers i and j with 0  i
< j  n, such that pi = pj. We can break s into s=xyz as
follows:
1. x = a1a2…ai
2. y = ai+1ai+2…aj
3. z = aj+1aj+2…am
– i.e., string x takes us to state pi. Then we somehow
repeat back to that state; at this point we are at input
symbol j, and the corresponding state is pj (where pi =
pj). Finally we finish by moving to an accepting state.
– Since i is less than j (not less than or equal to j) this
means that we must have at least one symbol for y, so y
may not be empty

Pumping Lemma Illustration
• The following automaton illustrates the
pumping lemma
p0
Start pi
x=a1…ai
y=ai+1…aj
z=aj+1…am
If this behavior is possible, then it means that xy*z must be in the language.

Using the Pumping Lemma
• To show that L is not regular, first assume that L is regular
in order to obtain a contradiction.
• Then use the pumping lemma to guarantee the existence of
a pumping length p such that all strings of length at least p
can be pumped
• Find a string s in L that has length p or greater but cannot
be pumped
– This is demonstrated by considering all ways of dividing s into x,y,
and z and showing that one or more of the conditions of the
pumping lemma are violated
– Typically we will show that condition 3 is violated
• Since the existence of s contradicts the pumping lemma if
L was regular means that L is not regular.

Pumping Lemma Proofs
• Tricky part - coming up with the string s.
– This may take some creative thinking and trial
and error, because for a non-regular language,
some strings may fit the pumping lemma
conditions, while others won’t.
– If a string works, you may need to pick another
one until you find one that leads to the
contradiction.

Pumping Lemma as a Game
• You can also think of the pumping lemma as an adversarial
game
– Player 1 picks the language L to be proved non-regular
– Player 2 picks p, the pumping length. Player 1 doesn’t know what p
is, so player 1 must devise a game plan that works for all possible p’s
(i.e. we must leave p as a variable)
– Player 1 picks string s, where s is in L
– Player 2 divides s into x,y, and z, obeying the constraints that are
stipulated in the pumping lemma (y ε, |xy|  p, xy*z  L).
– Player 1 “wins” by picking k, which may be a function of p, x, y, or z,
such that xykz is not in L.
• This game assumes player 2 is smart and if it is possible to
pick an xyz that does obey the constraints of the pumping
lemma, then he will do so!

Example 1
• Let B be the language {0n1n | n  0}. Use the
pumping lemma to show that this is not regular.
– Intuitively – not regular if you can’t build a DFA for it
• Assume that B is regular.
– Let p be the pumping length selected by the adversary.
Choose s to be the string 0p1p. This string is clearly a
member of B.
– s has length at least p, so it is a valid choice.

Example 1, Continued, 0n1n
• Our adversary has the following choices to split s into xyz,
according to the constraints of the pumping lemma, where
y may not be empty:
– The string y consists only of 0’s. Then we pick k=2. By condition
3, xy2z should also be in B. But this results in the string xyyz.
Since we added more 0’s with the addition of another y, this is not
in L.
– The string y consists only of 1’s. Then we pick k=2 and by the
same logic as above, the string xyyz would have more 1’s than 0’s
and this is also not in B.
– The string y consists of 1’s and 0’s. Then we pick k=2 and xyyz
may have the same number of 1’s and 0’s but now the 0’s and 1’s
are not in the desired order (we needed to have all the 0’s come
before the 1’s). Therefore, this string is not in B either.
• Contradiction no matter what the adversary chooses! B
cannot be regular.

Example 2
• Let C = { w | w has an equal number of 0’s and 1’s }. Use the pumping
lemma to show that this language is not regular.
• Assume that C is regular and let p be the pumping length selected by the
adversary.
• Choose s to be the string (01)p. This is clearly of length at least p and is
also in the language.
– Our adversary splits the string into an x, y, and z.
– Let’s say the adversary splits it into x=ε, y=01, and z=(01)p-1.
– Can we find a value k such that xykz is not in C?
• If k=0 then we just get the string xz, which is the string z. z has an equal number
of 0’s and 1’s so it is in C.
• If k=1 then we get the string xyz, which is also in C.
• If we pick k=2 then we get the string xyyz, which is also in C.
• No matter what value of k we pick, each resulting string is still in the language.
• This means that we didn’t pick the right string (or that the language
actually is regular).

Example 2, cont.
• Try again by picking s=0p1p. This string is also
clearly of length at least p and is also in the
language.
• The adversary breaks up the string s into xyz.
– But we know that since |xy|  p, then x and y must
consist entirely of 0’s.
– Based on condition 3, if we let k=2, then xyyz will have
more 0’s then there are 1’s so this is not in C. Similarly,
if we let k=0, then xz will have fewer 0’s then 1’s so
this is also not in C (we can pick k equal to any value
except 1).
– Therefore, the language is not regular

Example 2 extra
• Given our selection of s = 0p1p
• What if the adversary picked x=ε and z= ε?
• That is, the string y contains the entire string. Then it
would seem that xykz will still be in C, since y will contain
an equal number of 0’s and 1’s.
• But since |xy| must be  p this selection by the adversary is
not possible since it would leave only y, and for y to equal
0p1p, violates the constraint of |xy|  p

Example 3
• Let D = {ww | w  {0,1}*}. In other words, pick w equal to
any finite sequence of 0’s and 1’s. Then allow only those
strings that have this word in it back to back. Show that D is
non-regular using the pumping lemma.
• Assume that D is regular and let p be the pumping length
selected by the adversary. Choose s to be the string 0p0p. This
is clearly of length at least p and is also in the language.
• Our adversary splits the string into an x, y, and z. Let’s say the
adversary splits it into x=ε, y=00, and z=02p-2. Can we find a
value k such that xykz is not in D?
– No, for any value of k the resulting string is still in D. Obviously this
was not a good choice of a string s. Let’s pick another one.

Example 3, cont.
• Choose s to be the string 0p10p1. This is clearly a
member of D and has length of at least p.
• Our adversary splits the string into an x,y, and z.
Once again, since |xy|  p, we must have the case
that x and y consist entirely of zeros.
– If we pump y by letting k=2, then we now have more
zeros in the first half of the string then in the second
half, so the resulting string is no longer in D.
Therefore, the language is not regular.

Example 4
• Let E = {0i1j | i > j}. Show this is non-regular using the
pumping lemma.
• Assume that E is regular and let p be the pumping length
selected by the adversary. Choose s to be the string 0p+11p.
This is clearly of length at least p and is also in the language.
• Our adversary splits the string into an x, y, and z.
– Since |xy|  p, both x and y must consist entirely of zeros.
– If we pump y up, (k>0) then we end up with strings that are still in L.
– If we pump y down by allowing k=0, then we get the string xz.
• Removing the y decreases the number of 0’s in s. But we constructed s
so that there is exactly one more zero than one. So by removing a zero,
we now have the same or fewer zero’s than ones, so the resulting string is
no longer in E.
• Therefore, the language is not regular.

Example 5
• Let F = { | n >=0 }. That is, each string consists
of 1’s and is of length that is a perfect square:
– ε, 1, 1111, 111111111 , 1111111111111111, etc. (0, 1, 4,
9, 16, 25, 36, …)
• Notice that the gap between the length of the
string grows in the sequence.
– Large members of this sequence cannot be near each
other.
– If we subtract off the difference in length between
successive elements, we get 1, 3, 5, 7, 9, 11, 13, etc.
For position i where i >0, we get the difference from
position i and i-1 as 2*i -1.
2
1n

Example 5, cont.
• Assume that F is regular and let p be the pumping length
selected by the adversary.
• Let m = p2. Choose s to be the string 1m. This string is clearly
in F and is at least of length p.
• The adversary picks some strings x,y, and z.
– Consider the two strings xykz and xyk+1z. Both of these strings must be in
F.
– These two strings differ only by a single repetition of y, or |y| which we
know must be  p.
– But we saw that the length of the strings accepted by the language grows
in length by 2i-1, not by some fixed amount |y|. Each time we pump the
string we increase the value of i, so we can always find a value of i to
make 2i-1 larger than |y|.
– Consequently, we can always pick a large enough k such that assuming
xykz is in the language, xyk+1z cannot be in the language because the
length differential will be too small to equal to 2i-1.

Closure Properties of Regular
Languages
• We have seen that some languages are not regular
• On the other hand, certain operations on regular languages
are guaranteed to produce regular languages.
– The following theorems are referred to as the closure properties
of regular languages.
– Closure refers to some operation on a language, resulting in a new
language that is of the same “type” as those originally operated on,
i.e., regular.
• We won’t be using the closure properties extensively here;
consequently we will state the theorems and give some
examples. See the book for proofs of the theorems.

Closure under Union
• Let L and M be languages over . Then L  M
is the language that contains all strings that are
either in L or in M.
– We have already shown how to compute R+S, where
R+S is the union of two regular languages. If L=L(R)
and M=L(S) then L(R+S) is the same as L  M.
– Note that if  is different for L and M, then  for (L
 M) is the union of the alphabets for L and the
alphabets for M.

Closure under Complementation
• Let L and M be languages over . Then is the complement
of L, which is the set of strings of * that are not in L.
• In other words, the complement of a language is everything that
is not accepted by the language over our alphabet. Here is an
argument as to why complementation is closed. To complement
a language:
– First construct a DFA for that language
– Complement the accepting states of the DFA
– Note that this requires there be no missing transitions in the DFA. If the
automaton “dies” on missing edges, these states will be missing from the
complemented DFA (which should be accepting states).
L

Closure under Intersection
• Let L and M be languages over . Then L  M is
the language that contains all strings that are both
in L and M.
• To show closure under intersection, note
DeMorgan’s law which states:
• We have already shown closure under union and
complementation, therefore we also have closure
under intersection.
M
L
M
L 



Closure under Difference
• Let L and M be languages over . Then L – M,
the difference of L and M, is the set of strings
that are in L but not in M.
• To show closure, note that: L – M = L  .
Since we have shown closure under intersection
and complementation, we also have closure
under difference.
M

Closure under Reversal
The reversal of a string a1a2…an is the string written backwards, that is, anan-1an-2…a1.
We will use wR
to denote the reversal of string w. For example, 1011R
is 1101.
The reversal of a language L, written LR
, is the language consisting of the reversals of
all its strings. The reversal of a regular language produces another regular language.
We can show this informally using an automaton A for L(A):
 Reverse all the edges in the transition diagram for A
 Make the start state of A be the only accepting state for the new automaton
 Create a new start state p0 with transitions on ε to what were the original
accepting states of A
This creates a reversed automaton for A, that accepts a string iff A accepts wR
.

Closure under *, Concatenation
• Closure under Kleene Star
– We have already shown this for regular
expressions in the construction of an
equivalent ε-NFA for the star operation.
• Closure under concatenation
– We have already shown this for regular
expressions in the construction of an
equivalent ε-NFA for concatenation.

Closure under Homomorphism
• What is a homomorphism?
– Given a language L with alphabet 1, A homomorphism h
is defined from some alphabet 2. For symbol(s) a  1,
h(a) is some string from 2.
• We apply h to each symbol of a word w from L and concatenate
the results in order to get a new string. h(L) is the homomorphism
of every word in L.
– Example: h is the homomorphism from the alphabet
{0,1,2} to the alphabet {a,b} defined by h(0) = a, h(1) =
ab, h(2) = ba.
• h(0120) = aabbaa
• h(21120) = baababbaa
• h(01*2) = a(ab)*ba

Closure under Homomorphism
• Theorem: If L is a regular language over alphabet
, and h is a homomorphism on , then h(L) is
also regular.
– Informally, if L is turned into a regular expression, we
are substituting a regular expression for some other
regular expression matching the homomorphism. The
result is still a regular language.
– Note: we can expand homomorphisms to more general
substitution, where substituting a substring in L (instead
of an individual symbol) with some new string also
results in a language that is regular.

Inverse Homomorphism
• A homomorphism may be applied backwards; i.e. given
the h(L), determine what L is. This is denoted as h-1(L),
or the inverse homomorphism of L, which results in the
set of strings w in * such that h(w) is in L.
– Note that while applying the homomorphism to a string
resulted in a single string, we may get a set of strings in the
inverse.
– For example, if h is the homomorphism from the alphabet
{0,1,2} to the alphabet {a,b} defined by h(0) = a, h(1) = ab,
h(2) = ba.
• Given L is the language {ababa} what is h-1(L) ?
• We can construct three strings that map into ababa:
h-1={ 022, 110, 102 }
• The result of h-1 is also a regular language (see proof in book).

Decision Properties of Regular
Languages
• Given a (representation, e.g., RE, FA, of a)
regular language L, what can we tell about L?
• Since there are algorithms to convert between
any two representations, we can choose the
representation that makes whatever test we are
interested in easiest.

Decision Properties
• Membership: Is string w in regular language L?
– Choose DFA representation for L.
– Simulate the DFA on input w.
• Emptiness: Is L = Ø?
– Use DFA representation for L
– Use a graph-reachability algorithm (e.g. Breadth-First-
Search or Depth-First-Search or Shortest-Path) to test if
at least one accepting state is reachable from the start
state. If so, the language is not empty. If we can’t
reach a accepting state, then the language is empty.

Decision Properties
• Finiteness: Is L a finite language?
– Note that every finite language is regular (why?), but a
regular language is not necessarily finite.
– DFA method:
• Given a DFA for L, eliminate all states that are not reachable
from the start state and all states that do not reach an accepting
state.
• Test if there are any cycles in the remaining DFA; if so, L is
infinite, if not, then L is finite. To test for cycles, we can use a
Depth-First-Search algorithm. If in the search we ever visit a
state that we’ve already seen, then there is a cycle.

Decision Properties
• Equivalence: Do two descriptions of a language actually
describe the same language? If so, the languages are called
equivalent.
– For example, we’ve seen many different (and sometimes complex)
regular expressions that can describe the same language. How can
we tell if two such expressions are actually equivalent?
• To test for equivalence our strategy will be as follows:
– Use the DFA representation for the two languages
– Minimize each DFA to the minimum number of needed states
– If equivalent, the minimized DFA’s will be structurally identical
(i.e. there may be different names for the states, but all transitions
will go to identical counterparts in each DFA).

Minimization
• To test for equivalence on the previous slide, we need some
method to minimize a DFA
• We say that two states p and q in a DFA are equivalent if:
– For all input strings w, δ^(p, w) is an accepting state if and only if δ^(q,
w) is an accepting state.
– i.e if we have reached state p or q, then any other string we might get
that will lead to an accepting state from p will also lead to an accepting
state from q.
– Also any string we get that does not lead to an accepting state from p
also does not lead to an accepting state from q.
– If this condition holds, then p and q are equivalent. If this condition
does not hold, then p and q are distinguishable.
• The simplest case of a distinguishable pair is an accepting state
p and a non-accepting state q. In this case, δ^(p, ε) is an
accepting state, but δ^(q, ) is not an accepting. Therefore, any
pair of (accepting, non-accepting) states are distinguishable.

Algorithm to Discover
Distinguishable Pairs
1. Given an automaton A that has states q0…qn make a diagonal table
with labels 1 to n on the rows and 0 to n-1 on the columns.
2. Initialize the table by placing X’s for each pair that we know is
distinguishable. Initially, this is any pair of accepting and non-
accepting states.
3. Let p and q be states such that for some input symbol a, r = δ(p, a)
and s = δ(q, a). If the pair (r,s) is known to be distinguishable (i.e.
they have an X in their table entry) then the pair p and q are also
distinguishable. Place an X for (p,q) in the table.
4. Repeat step 3 until all pairs have been examined.
5. Repeat steps 3-4 again for any empty entries in the table. If no new
X’s can be placed, then the algorithm is complete. Any entries in
the table without an X are pairs of states that are equivalent.
Once the equivalent states have been identified, they can be combined into a
single state to make a new, minimized automaton. DFA’s have unique
minimum-state equivalents.

Simple Minimization Example
• Minimize the following DFA
p
Start
0
q
r
0
0
1
1 1
q
r
p q
Create Table:
“X” Known distinguishable states
X
X
(q,r) distinguishable?
On 0: both to p, not distinguishable
On 1: to (q,r), no X, so leave alone
Will never distinguish (q,r), states equiv!

Simple Minimization Example
• Combine q,r:
p
Start
0
q
r
0
1
1 1
p
Start
0,1
qr
0
1

Textbook Minimization Example
• Minimize the following:
A
Start B C D
E F G H
0
0
0
0
0
0
0
0
1
1
1
1
1
1
1
1

Initial Table - Minimization
B
C X X
D X
E X
F X
G X
H X
A B C D E F G

Table – After First Iteration
B X
C X X
D X X X
E X X X
F X X X X
G X X X X X
H X X X X X X
A B C D E F G

Table – Last Iteration
B X
C X X
D X X X
E X X X
F X X X X
G X X X X X X
H X X X X X X
A B C D E F G
States (B,H), (A,E) and (D,E) are equivalent

Minimized DFA
AE
Start BH C
DF G
0
0
0
0
0
1
1
1
1
1

Possible to beat the minimized DFA?
• Is it possible for some other, equivalent,
DFA to exist that does the same as our
minimized DFA but in fewer states?
• NO
– See text for proof
– If such a DFA existed, the minimization process
would find the non-distinguishable states

hop-chap4.ppt

More Related Content

Similar to hop-chap4.ppt (20)

Recently uploaded (20)

hop-chap4.ppt