Computer Language Theory

Chapter 1: Regular Languages

Dr. Gary Weiss, January 27 2008 1

Chapter 1.1: Finite Automata

Dr. Gary Weiss, January 27 2008 2

 What is a Computer?
• Not a simple question to answer precisely
– Computers are quite complicated
• We start with a computational model
– Different models will have different features and
may match a real computer better in some ways
and worse in others
• Our first model is the finite state machine or
finite automata

Dr. Gary Weiss, January 27 2008 3

 Finite Automata
• Models of computers with extremely limited
memory
– Many simple computers have extremely limited
memories and are in fact finite state machines
– Can you name any? Hint: several are in this
building but have nothing specifically to do with
our department
• Vending machine
• Elevator
• Thermostat
• Automatic door at supermarket
Dr. Gary Weiss, January 27 2008 4
 Automatic Door
• What is the desired behavior? Describe the actions and then
list the states.
– Person approaches, door should open
– Door should stay open while person going thru
– Door should shut if no one near doorway
– States are open and closed
• More details about automatic door
– Front pad Door Rear Pad
– Describe behavior now
• Hint: action depends not just on what happens, but what state you are
currently in
• If you walk thru door should stay open when you are on rear pad
• But if door is closed and someone steps on rear pad, door does not open

Dr. Gary Weiss, January 27 2008 5

 Automatic Door cont.
REAR, BOTH, FRONT, REAR,
NEITHER BOTH

FRONT

Closed NEITHER
Open

NEITHER FRONT REAR BOTH

CLOSED CLOSED OPEN CLOSED CLOSED
OPEN CLOSED OPEN OPEN OPEN
Dr. Gary Weiss, January 27 2008 6
 More on Finite Automata
• How many bits of data does this FSM store?
– 1 bit: open or closed
• What about state information for elevators,
thermostats, vending machines, etc?
• FSM used in speech processing, optical
character recognition, etc.
• Have you implemented FSM? What?
– I have implemented network protocols and expert
systems for diagnosing telecommunication
equipment problems
Dr. Gary Weiss, January 27 2008 7
 A finite automata M1
0
1 0
1

q1 q2 q3

0,1

• A finite automata M1 with 3 states

– We see the state diagram
• Start state q1, accept state q2 (double circle), and several
transitions
– If a string like 1101 will accept if ends in accept state or
else reject. What will it do?
– Can you describe all string that this model will accept?
• It will accept all strings ending in a 1 and any string with an even
number of 0’s following the last 1
Dr. Gary Weiss, January 27 2008 8
 Formal Definition of Finite Automata
• A finite automata is a 5-tuple (Q, , δ, q0, F)
– Q is a finite set called states
–  is a finite set called the alphabet
– δ : Q x   Q is the transition function
– q0  Q is the start state
– F  Q is the set of accept states

Dr. Gary Weiss, January 27 2016 9

 Describe M1 using Formal Definition
0
1 0
1

q1 q2 q3

0,1

• M1 = (Q, , δ, q0, F)
– Q=
– =
– δ:
– Start state:
– F=

Dr. Gary Weiss, January 27 2008 10

 Describe M1 using Formal Definition
0
1 0
1

q1 q2 q3

0,1

• M1 = (Q, , δ, q0, F)
– Q = {q1, q2, 0 1
– q3}
 = {0,1} q1 q1 q2
– q1 is the start state q2 q3 q2
– F = {q2} q3 q2 q2
Transition function δ
Dr. Gary Weiss, January 27 2008 11
 The Language of M1
• If A is the set of all strings that a machine M
accepts, then A is the language of M
– L(M) = A
– We also say that M recognizes A or M accepts A
• A machine may accept many strings, but only
one language
• Convention: M accepts string and recognizes a
language

Dr. Gary Weiss, January 27 2008 12

 What is the Language of M1?
• L(M1) = A or M1 recognizes A
• What is A?
– A = {w | …….}
– A = {w| w contains at least one 1 and an even
number of 0’s follows the last 1}

Dr. Gary Weiss, January 27 2008 13

 What is the Language of M2?
0
1
1

q1 q2

• M2 = {{q1,q2}, {0,1}, δ, q1, {q2}}

– I leave δ as an exercise
– What is the language of M2?
• L(M2) = {w| ? }
• L(M2) = {w| w ends in a 1}
Dr. Gary Weiss, January 27 2008 14
 What is the Language of M3?
0
1
1

q1 q2

• M3 is M2 with different start state

• What is the language of M3?
– L(M3) = {w| ? }
– L(M3) = {w| w ends in 0} [Not quite right! Why?]
– L(M3) = {w| w is the empty string ε or ends in 0}

Dr. Gary Weiss, January 27 2008 15

 What is the Language of M4
• M4 is a 5 state automata (Figure 1.12 on page
38)
• What does M4 accept?
– All strings that start and end with a or start and end
with b
– More simply, language is all string starting and
ending with the same symbol
• Note that length of 1 is okay

Dr. Gary Weiss, January 27 2008 16

 Construct M5 to do Modulo Arithmetic

• Let  = {RESET, 0, 1, 2}
• Construct M5 to accept a string only if the
sum of each input symbol is a multiple of 3
and RESET sets the sum back to 0 (1.13, page
39)

Dr. Gary Weiss, January 27 2008 17

 Now Generalize M5
• Generalize M5 to accept if sum of symbols is a
multiple of i instead of 3
– ({q0, q1, q2, q3, …, qi-1} , {0,1,2,RESET}, δ, q0, q0)
• δi(qj, 0) = qj
• δi(qj, 1) = qk where k=j+1 modulo i
• δi(qj, 2) = qk where k=j+2 modulo i
• δi(qj, RESET) = qo

• Note: as long as i is finite, we are okay and only need

finite memory (# of states)
• Could you generalize on  = {1, 2, 3, …k}?
Dr. Gary Weiss, January 27 2008 18
 Formal Definition of Accept
• Definition of M accepting a string:
– Let M = (Q, , δ, q0, F) be a finite automata and
let w=w1w2 …wn be a string where wi  .
– Then M accepts w if a sequence of states r0, r1, …,
rn in Q exists with 3 conditions
• r0=q0
• δ(ri, wi+1) = ri+1, for i =0, 1, …, n-1
• rn  F

Dr. Gary Weiss, January 27 2008 19

 Regular Languages
• Definition: A language is called a regular
language if some finite automata recognizes it
– That is, all of the strings in the language are
accepted by some finite automata
– Why should you expect proofs by construction
coming up in your next homework?

Dr. Gary Weiss, January 27 2008 20

 Designing Finite Automata
• You will need to design FA’s to accept a language
• Strategies
– Determine what you need to remember (the states)
• How many states to determine even/odd number of 1’s in an
input?
• What does each state represent
– Set the start and finish states based on what each state
represents
– Assign the transitions
– Check your solution: it should accept w  L and not accept
w not in L
– Be careful about the empty string
Dr. Gary Weiss, January 27 2008 21
 You Try Designing FAs
• Design a FA to accept the language of binary
strings where the number of 1’s is odd (page 43)
• Design a FA to accept all string with 001 as a
substring (page 44)
– What do you need to remember
• Design a FA to accept a string with substring
abab

Dr. Gary Weiss, January 27 2008 22

 Regular Operations
• Let A and B be languages. We define 3 regular
operations:
– Union: A  B = {x| x A or x B}
– Concatenation: A  B where {xy| xA and yB}
– Star: A* = {x1x2 ….xk| k ≥ 0 and each xi  A}
• Star is a unary operator on a single language
• Star repeats a string 0 or more times

Dr. Gary Weiss, January 27 2008 23

 Examples of Regular Operations
• Let A = {good, bad} and B = {boy, girl}
• Then what is:
–AUB
• A U B = {good, bad, boy, girl}
–AB
• A  B = {goodboy, goodgirl, badboy, badgirl}
– A*
• A* = {ε, good, bad, goodgood, goodbad, badbad,
badgood, goodgoodgood, …}

Dr. Gary Weiss, January 27 2008 24

 Closure
• The natural numbers is closed under addition
and multiplication (but not division and
subtraction)
• A collection of objects is closed under an
operation if applying that operation to
members of the collection returns an object in
the collection

Dr. Gary Weiss, January 27 2008 25

 Closure for Regular Languages
• Regular languages are closed under the 3
regular operators we just introduced
• Can you look ahead to see why we care?
– If these operators are closed, then if we can
implement each operator using a FA, then we can
build a FA to recognize a regular expression

Dr. Gary Weiss, January 27 2008 26

 Closure of Union
• Theorem 1.25: The class of regular languages is
closed under the union operation
– If A1 and A2 are regular languages then so is A1  A2
– How can we prove this? Use proof by construction.
• Assume M1 accepts A1 and M2 accepts A2
• Construct M3 using M1 and M2 to accept A1  A2
• We need to simulate M1 and M2 running in parallel and
stop if either reaches an accept state
– This last part is feasible since we can have multiple accept
states
– You need to remember where you would be in both machines
Dr. Gary Weiss, January 27 2008 27
 Closure of Union II
• You need to generate a state to represent the
state you would be in with M1 and M2
• Let M1 = (Q1, , δ1, q1, F1) and M2 = (Q2, , δ2, q2,
F2)
• Build M3 as follows (we will do Q, , q0, F, δ ):
– Q = {(r1,r2)| r1  Q and r2  Q (Cartesian product)
–  stays the same but could more generally be 1 2
– q0 is the pair (q1, q2)
– F = {(r1, r2)|r1  F1 or r2  F2}
– δ((r1,r2),a) = (δ(r1, a), δ2(r2, a))
Dr. Gary Weiss, January 27 2008 28
 Closure of Concatenation
• Theorem 1.26: The class of regular languages is
closed under the concatenation operator
– If A1 and A2 are regular languages then so is A1  A2
– Can you see how to do this simply?
• Not trivial since cannot just concatenate M1 and M2,
where start states of M2 become the finish states of M1
– Because we do not accept a string as soon as it enters the
finish state, we wait until string is done, so it can leave
and come back
– Thus we do not know when to start using M2
– This proof is easy if we have nondeterministic FA

Dr. Gary Weiss, January 27 2008 29

Chapter 1.2: Nondeterminism

Dr. Gary Weiss, January 27 2008 30

 Nondeterminism
• So far our FA is deterministic in that the state and next
symbol determines the next state
• In a nondeterministic machine, several choices may exist
• DFA’s have one transition arrow per alphabet symbol,
while NFAs have 0 or more for each and ε

0,1 0,1

1 0, ε 1
q1 q2 q3 q4

Dr. Gary Weiss, January 27 2008 31

 How does an NFA Compute?
• When there is a choice, all paths are followed
– Think of it as cloning a process and continuing
– If there is no arrow, the path terminates and the clone dies
(it does not accept if at an accept state when that
happens)
– An NFA may have the empty string cause a transition
– The NFA accepts if any path is in the accept state
– Can also be modeled as a tree of possibilities
• An alternative way of thinking of this
– At each choice you make one guess of which way to go
– You magically always guess the right way to go

Dr. Gary Weiss, January 27 2008 32

 Try Computing This!
0,1 0,1

1 0, ε 1
q1 q2 q3 q4

• Try out 010110

– Is it accepted?
• Yes
• What is the language?
– Strings containing a substring of 101 or 11

Dr. Gary Weiss, January 27 2008 33

 Construct an NFA
• Construct an NFA that accepts all string over {0,1}
with a 1 in the third position from the end
– Hint: the NFA stays in the start state until it guesses
that it is three places from the end

Dr. Gary Weiss, January 27 2008 34

 Construct an NFA
• Construct an NFA that accepts all string over
{0,1} with a 1 in the third position from the
end
– Hint: the NFA stays in the start state until it
guesses that it is three places from the end

0,1

1 0, 1 0,1
q1 q2 q3 q4

Dr. Gary Weiss, January 27 2008 35

 Can we generate a DFA for this?
• Yes, but it is more complicated and has 8
states
– See book Figure 1.32 page 51
– Each state represents the last 3 symbols seen,
where we assume we start with 000
– So, states 000, 001, 010, 011, …, 111
– What is the transition from 010
• On a 1 we go to 101
• On a 0 we go to 100

Dr. Gary Weiss, January 27 2008 36

 Formal Definition of Nondeterministic
Finite Automata
• Similar to DFA except  includes ε and next
state is not a state but a set of possible states
• A nondeterministic finite automata is a 5-tuple
(Q, , δ, q0, F) where
– Q is a finite set called states
–  is a finite set called the alphabet
– δ : Q x ε  P(Q) is the transition function
– q0  Q is the start state
– F  Q is the set of accept states

Dr. Gary Weiss, January 27 2008 37

 Example of Formal Definition of NFA
0,1 0,1

1 0, ε 1
q1 q2 q3 q4

• NFA N1 is (Q, , δ, q1, F) 0 1 ε

– Q = {q1, q2, q3, q4} q1 {q1} {q1, q2} 
–  = {0,1}
q2 {q3}  {q3}
– q1 is the start state
q3  {q4} 
– F = {q4}
q4 {q4} {q4} 
Dr. Gary Weiss, January 27 2008 38
 Equivalence of NFAs and DFAs
• NFAs and DFAs recognize the same class of
languages
– We say two machine are equivalent if they
recognize the same language
– NFAs have no more power than DFAs
• With respect to what can be expressed
• But NFAs may make it much easier to describe a given
language
– Every NFA has an equivalent DFA

Dr. Gary Weiss, January 27 2008 39

 Proof of Equivalence of NFA & DFA
• Proof idea
– Need to simulate an NFA with a DFA
– With NFA’s, given an input we follow all possible
branches and keep a finger on the state for each
– That is what we need to keep track of– the states
we would be in for each branch
– If the NFA has k states then it has 2k possible
subsets
• Each subset corresponds to one of the possibilities that
the DFA needs to remember
• The DFA will have 2k states
Dr. Gary Weiss, January 27 2008 40
 Proof by Construction
• Let N=(Q, , δ, q0, F) be the NFA recognizing A
• Construct DFA M = (Q’, , δ’, q0’, F’)
– Lets do the easy ones first (skip δ’ for now)
– Q’ = P(Q)
– q0’ ={q0}
– F’ = {R  Q’| R contains an accept state of N}
– Transition function
• The state R in M corresponds to a set of states in N
• When M reads symbol a in state R, it shows where a takes each state
• δ’(R,a) = Union of rR of δ(r,a)
– I ignore ε, but taking that into account does not
fundamentally change the proof– we just need to keep track
of more states
Dr. Gary Weiss, January 27 2008 41
 Example: Convert an NFA to a DFA
• See example 1.41 on page 57
– For now don’t look at solution DFA
– The NFA has 3 states: Q = {1, 2, 3}
– What are the states in the DFA?
• {, {1}, {2}, {3}, {1,2}, {1,3}, {2,3}, {1,2,3}}
– What are the start states of the DFA?
• The start states of the NFA including those reachable by ε-moves
• {1, 3}
– 3 is included because if we start in 1 we can immediately move to 3
– What are the accept states?
• {{1}, {1,2}, {1,3}, {1,2,3}}

Dr. Gary Weiss, January 27 2008 42

 Example: Convert an NFA to a DFA
• Now lets work on some of the transitions
– Let’s look at state 2 in NFA and complete the transitions for
state 2 in the DFA
• Where do we go from state 2 on an “a” and “b”
– On “a” to state 2 and 3 and on “b” to state 3
• So what state does {2} in DFA go to for a and b?
– Answer: on a to {2,3} and {3} for b
– Now lets do state {3}
• On “a” goes to {1,3} and on b goes to 
– Why {1, 3}? Because first goes to 1 then ε permits a move back to 3!
– Now check DFA, Figure 1.43 on page 58
• Any questions? Could you do it on a HW, exam, or quiz?
Dr. Gary Weiss, January 27 2008 43
 Closure under Regular Operations
• We started this before and did it for Union
only
– Union much simpler using NFA
• Concatenation and Star much easier using NFA
• Since DFAs equivalent to NFAs, we can now
just use NFAs
• In all cases, fewer states to keep track of,
because we can act as if we can always
“guess” correctly
Dr. Gary Weiss, January 27 2008 44
 Why do we care about closure?
• We need to look ahead
– A regular language is what a DFA/NFA accepts
– We are now introducing regular operators and
then will generate regular expressions from them
(Ch 1.3)
– We will want to show that the language of regular
expressions is equivalent to the language accepted
by NFAs/DFAs (i.e., a regular language)
– How do we show this?
• Basic terms in regular expression can generated by a FA
• We can implement each operator using a FA and the
combination is still able to be represented using a FA

Dr. Gary Weiss, January 27 2008 45

 Closure Under Union
• Given two regular languages A1 and A2
recognized by two NFAs N1 and N2, construct
N to recognize A1  A2
• How do we construct N? Think!
– Start by writing down N1 and N2. Now what?
– Add a new start state and then have it take ε
branches to the start states of N1 and N2

Dr. Gary Weiss, January 27 2008 46

 Closure under Concatenation
• Given two regular languages A1 and A2
recognized by two NFAs N1 and N2, construct N
to recognize A1  A2
• How do we do this?
– The complication is that we did not know when to
switch from handling A1 to A2 since can loop thru
an accept state
– Solution with NFA:
• Connect every accept state in N1 to every start state in
N2 using an ε transition
– don’t remove transitions from accept state in N1 back to N1
Dr. Gary Weiss, January 27 2008 47
 Closure under Concatenation II
• Given:
– N1 = (Q1, , δ1, q1, F1) recognizes A1
– N2 = (Q2, , δ2, q2, F2) recognizes A2
• Construct N=(Q1  Q2, , δ, q1, F2) so that it
recognizes A1 A2
δ1(q,a) q  Q1 and q  F1
δ(q,a) = δ1(q,a) q  F1 and a  ε
δ1(q,a){q2} q  F1 and a = ε
δ2(q,a) q  Q2

Dr. Gary Weiss, January 27 2008 48

 Closure under Star
• We have a regular language A1 and want to prove that
A1* is also regular
– Note (ab)* = {, ab, abab, ababab, ...}
• Proof by construction
– Take the NFA N1 that recognizes A1 and construct N from it
that recognizes A1*
– How do we do this?
• Add new ε-transition from accept states to start state
• Then make the start state the accept state so that  is accepted
– This almost works, but not quite. What is the problem?
» May have transition from intermediate state to start state and
should not accept this.
• Solution: add a new start state with an ε-transition to the original
start state and have ε-transitions from accept states to old start state
Dr. Gary Weiss, January 27 2008 49
Closure under Star

ε
ε
ε

Dr. Gary Weiss, January 27 2008 50

Chapter 1.3: Regular Expressions

Dr. Gary Weiss, January 27 2008 51

 Regular Expressions
• Based on the regular operators
• Examples:
– (0  1)0*
• A 0 or 1 followed by any number of 0’s
• Concatenation operator implied
– What does (0  1)* mean?
• All possible strings of 0 and 1
– Not 0* or 1* so does not require that commit to 0 or 1 before
applying * operator
• Assuming  = {0,1}, then equivalent to *

Dr. Gary Weiss, January 27 2008 52

 Definition of Regular Expression
• R is a regular expression if R is
1. a, for some a in alphabet 
2. ε
3. 
4. (R1  R2), where R1 and R2 are regular expressions
5. (R1  R2), where R1 and R2 are regular expressions
6. (R1*), where R1 is a regular expression
• Note:
– This is a recursive definition, common in computer
science
• R1and R2 always smaller than R, so no issue of infinite recursion
–  means language does not include any strings and ε
means it includes the empty string
Dr. Gary Weiss, January 27 2008 53
 Examples of Regular Expressions
• 0*10* =
– {w| w contains a single 1}
• *1*=
– {w| w has at least one 1}
• 01  01 =
– {01, 10}
• (0  ε)(1  ε) =
– {ε, 0, 1, 01}

Dr. Gary Weiss, January 27 2008 54

 Equivalence of Regular Expressions
and Finite Automata
• Theorem: A language is regular if and only if
some regular expression describes it
– This has two directions so we need to prove:
• If a language is described by a regular expression then
it is regular
• If a language is described by a regular expression then
it is regular
– We will do both directions

Dr. Gary Weiss, January 27 2008 55

 Proof: Regular Expression  Regular Language

• Proof idea: Given a regular expression R

describing a language L, we should …
– Show that some FA recognizes it
– Use NFA since may be easier and equivalent to DFA
• How do we do this?
– We will use definition of a regular expression and
show that we can build a FA covering each step.
• We will do quickly with two parts:
– Steps 1,2 and 3 of definition (handle a, ε, and  )
– Steps 4,5 and 6 (handle union, concatenation, and star)

Dr. Gary Weiss, January 27 2008 56

 Proof Continued
• For steps 1-3 we construct the FA below. As a
reminder:
1. a, for some a in alphabet 
2. ε
3. 

a ε 
a

Dr. Gary Weiss, January 27 2008 57

 Proof Continued
• For steps 4-6 (union, concatenation and star)
we use the proofs we already constructed to
show that FA are closed under union,
concatenation, and star
• So we are done with the proof in one direction
• Now lets try an example

Dr. Gary Weiss, January 27 2008 58

 Example: Regular Expression  NFA

• Convert (ab  a)* to an NFA

– See example 1.56 page 68
• Lets describe the outline of what we need to do
– Handle a
– Handle ab
– Handle ab  a
– Handle (ab  a)*
• In the book they have states for ε-transitions. They
seem unnecessary and may confuse you. They are in
fact unnecessary in this case.
• Now we need to do the proof in the other
direction
Dr. Gary Weiss, January 27 2008 59
Proof: Regular Language  Regular Expression

• A regular language is described by a DFA

– Need to show that can convert any DFA to a
regular expression
– The book goes through several pages (Lemma 1.60
page 69 – 74) that does not really add much
insight
• You can skip this. For the most part, if you understand
the ideas for going in the previous direction, you also
understand this direction.
• But you should be able to handle an example …

Dr. Gary Weiss, January 27 2008 60

 Example: DFA  Regular Expression

• This example is on page 75

• For the DFA below, what is the equivalent
regular expression?
Answer: a*b(a  b)*
a
1

a, b
2
Dr. Gary Weiss, January 27 2008 61
Chapter 1.4: Nonregular Languages

… and not the real fun begins

Never has something so simple confused so many –
Dr. Weiss

Dr. Gary Weiss, January 27 2008 62

 Non-Regular Languages
• Do you think every language is regular?
– That would mean that every language can be
described by a FA
• What might make a language non-regular?
Think about the properties of a finite
automata.
– Answer: finite memory
– So a language is not regular if you need infinite
memory
Dr. Gary Weiss, January 27 2008 63
 Some Example Questions
• Are the following languages regular?
– L1 = {w| w has an equal number of 0’s and 1’s}
– L2 = {w| w has at least 100 1’s}
– L3 = {w| w is of the form 0n1n, n≥ 0}
• First, write out some of the elements in each
to ensure you have the terminology down
– L1 = {, 01, 10, 1100, 0011, 0101, 1010, 0110, …}
– L2 = {(100 1’s), 0(100 1’s), 1(100 1’s), …}
– L3 = {, 01, 0011, 000111, …}

Dr. Gary Weiss, January 27 2008 64

 Answers
• Answers:
– L1 and L3 are not, they require infinite memory
• You cannot build a FA to recognize this language
– L2 certainly is regular
• We will be studying only infinite languages

Dr. Gary Weiss, January 27 2008 65

 What is Wrong with This?
• Question 1.36 from the book asks
– Bn = {ak|where k is a multiple of n}, show for n≥1
Bn is regular.
– How is this regular? How is this question different
from the ones before?
• Each language has a specific value of n, so n is not a
free variable as in other examples. However, k is a free
variable. But the number of states is bounded by n, not
k.

Dr. Gary Weiss, January 27 2008 66

 More on Regular Languages
• Regular languages can be infinite but must be
described using finite number of states
– Thus there are restrictions on the structure of
regular languages
– For a FA to generate an infinite set of string, clear
there must be a ______ between some states
• loop
– This leads to the (in)famous pumping lemma

Dr. Gary Weiss, January 27 2008 67

 Pumping Lemma for Regular Languages

• The pumping lemma states that all regular

languages have a special property
• If a language does not have this property it is
not regular
– So can use to prove a language non-regular
– Note: the pumping lemma can hold and a
language still not be regular. This is not usually
highlighted.

Dr. Gary Weiss, January 27 2008 68

 Pumping Lemma II
• Pumping lemma property
– Every string in a regular language L with length greater
than the pumping length p can be “pumped”
– This means every string s  L contains a section that
can be repeated any number of times (via a loop)
– The string s can be written as xyz where
1. For each i ≥ 0, x yi z  L
2. |y| > 0, and
3. |xy| ≤ p

Dr. Gary Weiss, January 27 2008 69

 Pumping Lemma Conditions
• Condition 1: for each i ≥ 0, x yi z  L
– This just says that there is a loop
• Condition 2: |y| > 0
– Without this condition, then there really would be no loop
• Condition 3: |xy| ≤ p
– We don’t allow more states than the pumping length, since
we want to bound the amount of memory
• All together, the conditions allow either x or z to be ε
but not both
– So loop need not be in the middle, which would be limiting

Dr. Gary Weiss, January 27 2008 70

 Pumping Lemma Proof Idea
• Set the pumping lemma length p to number of
states of the FA
– If length of s ≤ pumping lemma trivially holds, so
ignore these strings
– Consider the states that the FA goes through for s
• Since there are only p states and length s > p, by
pigeonhole property one state much be repeated
– This means there is a cycle

Dr. Gary Weiss, January 27 2008 71

 Example 1
• Let B be the language {0n1n| n≥ 0} (Ex 1.73)
– Prove B is not regular
– We will use proof by contradiction. Assume B is regular.
Now pick a string that will cause a problem.
– What string? Use the pumping length p in the string.
– Try 0p1p
• We need x yi z, let’s focus on y.
– If y all 0’s or all 1’s, then if xyz L then xyyz  L
– If y a mixture of 0 and 1, then 0’s and 1’s in s not completely
separated
– But even simpler than this if use condition 3, which you should
» Then y must be all 0’s and hence “pumping up” leads to a
contradiction
Dr. Gary Weiss, January 27 2008 72
 Example 2
• Let C = {w|w has equal number of 0’s and 1’s} (Ex 1.74)
– Can you do this with finite memory?
• No
– Prove C is not regular, using proof by contradiction
– Assume C is regular. Pick a problematic string.
• Let’s try 0p1p
• If we pick y =01, can we pump it and have pumped string  C?
– Yes! Each time we pump (i.e., loop) we add one 0 and 1. So works.
– Note however that pumped string not in 0n1n, but that is okay since in C
– But cannot have x and z be ε
» If |xy| < p then x and y can only be 0, since we start with 0 p
» So y can only have 0s and pumping break equality

Dr. Gary Weiss, January 27 2008 73

 Common-Sense Interpretation
• FA can only use finite memory. If infinite
strings, then the loop must handle this
– If there are two parts that can generate infinite
sequences, we must find a way to link them in the
loop
• If not, is not regular
• Examples: 0n1n equal numbers of 0s and 1s

Dr. Gary Weiss, January 27 2008 74

 Example 3
• Let F = {ww| w  {0,1}*} (Ex 1.75)
– F = {, 00, 11, 0011, 0101, …}
– Can you do this with finite memory?
• No
– Use proof by contradiction. Pick s  F that will be
problematic
• 0p10p1
– If x and z could be ε, then easy (use y=0p10p1)
– Since |xy| < p, y must be all 0’s
– If we pump y, then only adding 0’s. That will be a problem.
Since 0’s separated by 1 must be equal

Dr. Gary Weiss, January 27 2008 75

 Example 4
• Let D = {1n2| n ≥ 0}
– D = {, 1, 1111, 111111111, …}
– Proof by contradiction
– Choose 1p2
• Assume we have an xyz  D
• What about xyyz? The # of 1’s differs from xyz by |y|
– Since |xy| ≤ p then |y| ≤ p
– Thus xyyz has at most p more 1’s than xyz
– So if xyz has length ≤ p2 then xyyz ≤ p2 +p
– But p2 + p < (p+1)2 = p2 + 2p + 1
– Thus length of xyyz lies between consecutive perfect squares and
hence xyyz D

Dr. Gary Weiss, January 27 2008 76

 Example 5
• Let E = {0i1j| i > j}
• Assume E is regular and let s = 0p+11p
• By condition 3, y must be all 0’s
– What can we say about xyyz?
• Adding the extra y increases number of 0’s, which
appears to be okay since i > j is okay
– But we can pump down. What about xy0z = xz?
• Since s has one more 0 than 1, removing at least one 0
leads to a contradiction. So not regular.

Dr. Gary Weiss, January 27 2008 77

 What you need to be able to do
• You should be able to handle examples like 1-3.
• Example 5 is not really any more difficult, just one
more thing to think about
• Example 4 was tough, so I won’t expect everyone to
get an example like that
• You need to be able to handle the easy examples
– On an exam, I would probably give you several problems
that are minor variants of these examples
• Try to reason about the problem using “common
sense” and then use that to drive your proof
• The homework problems will give you more practice

Dr. Gary Weiss, January 27 2008 78