# n - The Chinese University of Hong Kong

```Fall 2008
The Chinese University of Hong Kong
CSC 3130: Automata theory and formal languages
Limitations of finite automata
Andrej Bogdanov
http://www.cse.cuhk.edu.hk/~andrejb/csc3130
Many examples of regular languages
0
q0
1
1
q1
0
((0 + 1)0 + (0 + 1)(0 + 1)(0 + 1))*
0, 1
q0
1
q1
0
q2
1
q3
all strings not containing pattern 010 followed by 101
Is every language regular?
Which are regular?
L1 = {0n1m: n, m ≥ 0}
S = {0, 1}
L2 = {0n1n: n ≥ 0}
L3 = {1n: n is divisible by 3}
S = {1}
L4 = {1n: n is prime}
L5 = {x: x has same number of 0s and 1s}
L6 = {x: x has same number of patterns 01 and 10}
S = {0, 1}
Which are regular?
L1 = {0n1m: n, m ≥ 0} = 0*1*, so regular
L2 = {0n1n: n ≥ 0} = {e, 01, 0011, 000111, …}
• Let’s try to design a DFA for it
… it appears that we need infinitely many states!
A non-regular language
• Theorem
The language L2 = {0n1n: n ≥ 0} is not regular.
• To prove this, we argue by contradiction:
– Suppose we have managed to construct a DFA M for L2
– We show something must be wrong with this DFA
– In particular, M must accept some strings not in L2
A non-regular language
imaginary DFA for L2 with n states
x
M
• What happens when we run M on input x = 0n+11n+1?
– M better accept, because x  L2
A non-regular language
0
x
0
0
0
M
0
0r1n+1
• What happens when we run M on input x = 0n+11n+1?
– M better accept, because x  L2
– But since M has n states, it must revisit at least one of its
Pigeonhole principle
Suppose you are tossing n + 1 balls into n bins.
Then two balls end up in the same bin.
• Here, balls are 0s, bins are states:
If you have a DFA with n states and it reads
n + 1 consecutive 0s, then it must end up in the
same state twice.
A non-regular language
0
x
0
0
0
M
0
0r1n+1
• What happens when we run M on input x = 0n+11n+1?
– M better accept, because x  L2
– But since M has n states, it must revisit at least one of its
– But then the DFA must contain a loop with 0s
A non-regular language
0
0
0
0
M
0
0r1n+1
• The DFA will then also accept strings that go around
the loop multiple times
• But such strings have more 0s than 1s, so they are not
in L2!
General method for showing non-regularity
• Every regular language L has a property:
an
z
a1
…
ak
ak+1 … an-1
an+1…am
• For every sufficiently long input z in L, there is a
“middle part” in z that, even if repeated several times,
keeps the input inside L
Pumping lemma for regular languages
• Theorem: For every regular language L
There exists a number n such that for every
string z in L, we can write z = u v w where
 |uv| ≤ n
 |v| ≥ 1
 For every i ≥ 0, the string u vi w is in L.
z
…
u
v
…
w
Proving non-regularity
• If L is regular, then:
There exists n such that for every z in L, we can
write z = u v w where |uv| ≤ n, |v| ≥ 1 and
 For every i ≥ 0, the string u vi w is in L.
• So to prove L is not regular, it is enough to show:
For every n there exists z in L, such that for
every way of writing z = u v w where
|uv| ≤ n and |v| ≥ 1, the string u vi w is not
in L for some i ≥ 0.
Proving non regularity
For every n there exists z in L, such that for
every way of writing z = u v w where
|uv| ≤ n and |v| ≥ 1, the string u vi w is not
in L for some i ≥ 0.
• This is a game between you and an imagined
1 choose n
2 write z = uvw (|uv| ≤ n,|v| ≥ 1)
you
choose z  L
choose i
you win if uviw  L
Proving non-regularity
• You need to give a strategy that, regardless of what
the adversary does, always wins you the game
1 choose n
2 write z = uvw (|uv| ≤ n,|v| ≥ 1)
you
choose z  L
choose i
you win if uviw  L
Example
you
1 choose n
2 write z = uvw (|uv| ≤ n,|v| ≥ 1)
choose z  L
choose i
you win if uviw  L
S = {0, 1}
• L2 = {0n1n: n ≥ 0}
you
1 choose n
2 write z = uvw (|uv| ≤ n,|v| ≥ 1)
u=
0j,
0k,
0l1n+1
v=
w=
j+k+l=n+1
z = 0n+11n+1
i=2
uviw
= 0j+2k+l1n+1
= 0n+1+k1n+1
L
More examples
L3 = {1n: n is divisible by 3}
S = {1}
L4 = {1n: n is prime}
L5 = {x: x has same number of 0s and 1s}
L6 = {x: x has same number of patterns 01 and 10}
L7 = {x: x has more 0s than 1s}
L8 = {x: x has different number of 0s and 1s}
S = {0, 1}
```