15-453

FORMAL LANGUAGES,
AUTOMATA AND
COMPUTABILITY
FIRST HOMEWORK IS DUE
Thursday, January 22
NON-DETERMINISM

THURSDAY JAN 18
M = (Q, Σ, , q0, F) where Q = {q0, q1, q2, q3}

Σ = {0,1}
 : Q  Σ → Q transition function *
q0  Q is start state
F = {q1, q2}  Q accept states

q1 1 
0
0,1 * q0
0
q0
1
q1
1
q0
q1 q2 q2
M q2
q2 q3 q2
0 0
q3 q0 q2
1
q3
 deterministic DFA
A ^ finite automaton ^ is a 5-tuple M = (Q, Σ, , q0, F)
Q is the set of states (finite)
Σ is the alphabet (finite)
 : Q  Σ → Q is the transition function
q0  Q is the start state
F  Q is the set of accept states

M accepts a string w if the process ends in

a double circle
 deterministic DFA
A ^ finite automaton ^ is a 5-tuple M = (Q, Σ, , q0, F)
Q is the set of states (finite)
Σ is the alphabet (finite)
 : Q  Σ → Q is the transition function
q0  Q is the start state
F  Q is the set of accept states
Let w1, ... , wn  Σ and w = w1... wn  Σ*
Then M accepts w if there are r0, r1, ..., rn  Q, s.t.
1. r0=q0
2. (ri, wi+1 ) = ri+1, for i = 0, ..., n-1, and
3. rn  F
 deterministic DFA
A ^ finite automaton ^ is a 5-tuple M = (Q, Σ, , q0, F)
Q is the set of states (finite)
Σ is the alphabet (finite)
 : Q  Σ → Q is the transition function
q0  Q is the start state
F  Q is the set of accept states

L(M) = set of all strings machine M accepts

A language L is regular if it is recognized by a

deterministic finite automaton,
i.e. if there is a DFA M such that L = L (M).
 UNION THEOREM
The union of two regular languages
is also a regular language

Intersection THEOREM

The intersection of two regular

languages is also a regular language
 Complement THEOREM

The complement of a regular

languages is also a regular language

In other words,
if L is regular than so is L,
where L= { w  Σ* | w  L }

Proof ?
 THE REGULAR OPERATIONS

Union: A  B = { w | w  A or w  B }

Intersection: A  B = { w | w  A and w  B }

Negation: A = { w  Σ* | w  A }

Reverse: AR = { w1 …wk | wk …w1  A }

Concatenation: A  B = { vw | v  A and w  B }

Star: A* = { w1 …wk | k ≥ 0 and each wi  A }

 Reverse THEOREM
The reverse of a regular languages
is also a regular language
 REVERSE CLOSURE
Regular languages are closed under reverse

Assume L is a regular language and M

recognizes L

We build MR that accepts LR

If M accepts w then w describes a directed

path in M from start to an accept state

Define MR as M with the arrows reversed

MR IS NOT ALWAYS A DFA!
It may have many start states
Some states may have too
many outgoing edges, or none
1 0,1
0

0 0 1
1
 NON-DETERMINISM
1 0,1
0

0 0 1
1

What happens with 100?

We will say that the machine accepts if there is
some way to make it reach an accept state
IBM JOURNAL APRIL 1959
Turing Award winning paper
 EXAMPLE

0,1
0,1

0,ε 0

At each state, possibly zero, one or many

out arrows for each   Σ or with label ε
 EXAMPLE
1
1 0,1

ε 0

Possibly many start states

 EXAMPLE
1

0
L(M)={1,00}
A non-deterministic finite automaton (NFA)
is a 5-tuple N = (Q, Σ, , Q0, F)

Q is the set of states

Σ is the alphabet
 : Q  Σε → 2Q is the transition function
Q0  Q is the set of start states
F  Q is the set of accept states

2Q is the set of subsets of Q and Σε = Σ  {ε}

Let w Σ* and suppose w can be written as
w1... wn where wi  Σε (ε is viewed as representing
the empty string)

Then N accepts w if there are r0, r1, ..., rn  Q

such that

1. r0  Q0
2. ri+1  (ri, wi+1 ) for i = 0, ..., n-1, and
3. rn  F

L(N) = the language recognized by N

= set of all strings machine N accepts

A language L is recognized by an NFA N

if L = L (N).
 1
q2 q4

0
N = (Q, Σ, , Q0, F)
ε
q3 Q = {q1, q2, q3, q4}
0 Σ = {0,1}
Q0 = {q1, q2}
q1
F = {q4}  Q
(q2,1) = {q4}
00  L(N)? (q3,1) = 
01  L(N)? (q1,0) = { q3}
 Deterministic Non-Deterministic
Computation Computation

reject

accept or reject accept

 MULTIPLE START STATES
We allow multiple start states for NFAs,
and Sipser allows only one

Can easily convert NFA with many start

states into one with a single start state:

ε ε
ε
UNION THEOREM FOR NFAs

0 0

1
0
1
 NFAs ARE SIMPLER THAN DFAs
An NFA that recognizes the language {1}:

A DFA that recognizes

the language {1}: 0,1
0

1 0,1
 Theorem: Every NFA has an equivalent* DFA

Corollary: A language is regular iff

it is recognized by an NFA

Corollary: L is regular iff LR is regular

* N is equivalent to M if L(N) = L (M)

 FROM NFA TO DFA
Input: N = (Q, Σ, , Q0, F)
Output: M = (Q, Σ, , q0, F)

Q = 2Q To learn if NFA accepts, we

could do the computation
in parallel, maintaining the
set of states where all
threads are
reject
Idea:
Q = 2Q
accept
 FROM NFA TO DFA
Input: N = (Q, Σ, , Q0, F)
Output: M = (Q, Σ, , q0, F)

Q = 2Q
 : Q  Σ → Q
(R,) =  ε( (r,) ) *
rR
q0 = ε(Q0)
* F = { R  Q | f  R for some f  F }

For R  Q, the ε-closure of R, ε(R) = {q that can be reached

from some r  R by traveling along zero or more ε arrows},
Given: NFA N = ( {1,2,3}, {a.b},  , {1}, {1} )
Construct: equivalent DFA M

N
1
a
a b
ε

a,b
2 3

ε({1}) = {1,3}
 N = ( Q, Σ, , Q0, F )
Given: NFA N = ( {1,2,3}, {a,b},  , {1}, {1} )
Construct: equivalent DFA M = (Q, Σ, , q0, F)
N  a b
1 
a {1}
a b
ε {2}
{3}

2 a, b 3

ε({1}) = {1,3}
 N = ( Q, Σ, , Q0, F )
Given: NFA N = ( {1,2,3}, {a,b},  , {1}, {1} )
Construct: equivalent DFA M = (Q, Σ, , q0, F)
N  a b
1 
a {1}
a b
ε {2}
{3}
a, b {1,2}
2 3
{1,3}
{2,3}
q0 = ε({1}) = {1,3}
{1,2,3}
 N = ( Q, Σ, , Q0, F )
Given: NFA N = ( {1,2,3}, {a,b},  , {1}, {1} )
Construct: equivalent DFA M = (Q, Σ, , q0, F)
N  a b
1 
a {1}
a b
ε {2}
{3}
2 a, b {1,2}
3
{1,3}
q0 = ε({1}) = {1,3} {2,3}
{1,2,3}
 N = ( Q, Σ, , Q0, F )
Given: NFA N = ( {1,2,3}, {a,b},  , {1}, {1} )
Construct: equivalent DFA M = (Q, Σ, , q0, F)
N  a b
1   
a {1}
a b
ε {2}
{3}
a, b {1,2}
2 3
{1,3}
{2,3}
q0 = ε({1}) = {1,3}
{1,2,3}
 N = ( Q, Σ, , Q0, F )
Given: NFA N = ( {1,2,3}, {a,b},  , {1}, {1} )
Construct: equivalent DFA M = (Q, Σ, , q0, F)
N  a b
1   
a {1}  {2}
a b
ε {2}
{3}
a, b {1,2}
2 3
{1,3}
{2,3}
q0 = ε({1}) = {1,3}
{1,2,3}
 N = ( Q, Σ, , Q0, F )
Given: NFA N = ( {1,2,3}, {a,b},  , {1}, {1} )
Construct: equivalent DFA M = (Q, Σ, , q0, F)
N  a b
1   
a {1}  {2}
a b
ε {2} {2,3} {3}
{3}
a, b {1,2}
2 3
{1,3}
{2,3}
q0 = ε({1}) = {1,3}
{1,2,3}
 N = ( Q, Σ, , Q0, F )
Given: NFA N = ( {1,2,3}, {a,b},  , {1}, {1} )
Construct: equivalent DFA M = (Q, Σ, , q0, F)
N  a b
1   
a {1}  {2}
a b
ε {2} {2,3} {3}
{3} {1,3} 
a, b {1,2} {2,3} {2,3}
2 3
{1,3} {1,3} {2}
{2,3} {1,2,3} {3}
q0 = ε({1}) = {1,3} {1,2,3}
{1,2,3} {2,3}
 N = ( Q, Σ, , Q0, F )
Given: NFA N = ( {1,2,3}, {a,b},  , {1}, {1} )
Construct: equivalent DFA M = (Q, Σ, , q0, F)
N  a b
1   
a {1}  {2}
a b
ε {2} {2,3} {3}
{3} {1,3} 
a, b {1,2} {2,3} {2,3}
2 3
{1,3} {1,3} {2}
{2,3} {1,2,3} {3}
q0 = ε({1}) = {1,3} {1,2,3}
{1,2,3} {2,3}
REGULAR LANGUAGES CLOSED
UNDER CONCATENATION

Given DFAs M1 and M2, construct NFA by

connecting all accept states in M1 to start
states in M2
REGULAR LANGUAGES CLOSED
UNDER STAR
Let L be a regular language and M be a
DFA for L
We construct an NFA N that recognizes L*
ε
1
0
0,1

ε 1

0 0

1 ε
Formally:
Input: M = (Q, Σ, , q1, F)
Output: N = (Q, Σ, , {q0}, F)
Q = Q  {q0}
F = F  {q0}

{(q,a)} if q  Q and a ≠ ε
{q1} if q  F and a = ε
(q,a) = {q1} if q = q0 and a = ε
 if q = q0 and a ≠ ε
 else
 L(N) = L*
Assume w = w1…wk is in L*, where w1,…,wk  L
We show N accepts w by induction on k
Base Cases:
 k=0
 k=1
Inductive Step:
Assume N accepts all strings v = v1…vk  L*, vi L,
and let u = u1…ukuk+1  L*, uj  L,
Since N accepts u1…uk and M accepts uk+1,
N must accept u
Assume w is accepted by N, we show w  L*
If w = ε, then w  L*
If w ≠ ε
ε

 L*

 L*
accept
REGULAR LANGUAGES ARE COLSED
UNDER REGULAR OPERATIONS
Union: A  B = { w | w  A or w  B }

Intersection: A  B = { w | w  A and w  B }

Negation: A = { w  Σ* | w  A }

Reverse: AR = { w1 …wk | wk …w1  A }

Concatenation: A  B = { vw | v  A and w  B }

Star: A* = { w1 …wk | k ≥ 0 and each wi  A }

 SOME LANGUAGES ARE
NOT REGULAR
B = {0n1n | n ≥ 0} is NOT regular!
WHICH OF THESE ARE REGULAR

C = { w | w has equal number of 1s and 0s}

NOT REGULAR

D = { w | w has equal number of

occurrences of 01 and 10}
REGULAR!!!
 THE PUMPING LEMMA
Let L be a regular language with |L| = 

Then there exists a positive integer P

such that
if w  L and |w| ≥ P
then w = xyz, where:
1. |y| > 0
2. |xy| ≤ P
3. xyiz  L for any i ≥ 0
Let M be a DFA that recognizes L
Let P be the number of states in M
Assume w  L is such that |w| ≥ P
We show w = xyz 1. |y| > 0
2. |xy| ≤ P
3. xyiz  L for any i ≥ 0
x

…
q0 qi qj q|w|

There must be j > i such that qi = qj

 USING THE PUMPING LEMMA
Use the pumping lemma to prove that
B = {0n1n | n ≥ 0} is not regular

Hint: Assume B is regular, and try pumping s = 0P1P

If B is regular, s can be split into s = xyz,

where for any i ≥ 0, xyiz is also in B
If y is all 0s: xyyz has more 0s than 1s
If y is all 1s: xyyz has more 1s than 0s
If y has both 1s and 0s:
xyyz will have some 1s before some 0s
 For next time
Read Chapter 1.2 of the book.

Also, get started on the homework ASAP!!