Lecture 3

CSC 341 

Automata etc 

Rhys Price Jones 

Week 3 

Friday, February 8, 13

Proving a Language is Regular 

Method 1 

Build a FA for it 

Example L = {w | w∊(0+1)*, binary number 

w is divisible by 5} 

Now convince 

me L = L(M) 



Method 2 

Describe a FA for it 

Example L = {w | w∊(0..F)*, hex number w is 

divisible by 479} 

M has 480 states q1..q480 

qn corresponds to “The string so far is a binary number congruent to n mod 479” 

Except q480 corresponds to congruence to 0 

δ(qi,0) = qj iff j ≡ 16i mod 479 

Now convince 

δ(qi,1) = qj iff j ≡ 16i+1 mod 479... 

δ(qi,F) = me L = L(M) 

qj iff j ≡ 16i+15 mod 479 

Start state q0 has δ(q0,0) = q481, δ(q0,i) = qi 

Accept states q481 and q480 



Method 3 

Give me a r.e. for it 

Example L = {w | w∊(0+1)*, w is a bunch of 0 

followed by a bunch of 1 followed by a bunch of 0} 

r = 0 * 1 * 0 * 

Now convince 

me L = L(r) 



Method 4 

Describe a r.e. for it 

Example L is a finite language consisting of 

the strings w1,w2,..wn 

r = w1+w2+..wn 

Now convince 

me L = L(r) 



Method 5 

Use closure properties 

Example L = {w∊(0+1)* | w is a binary 

number divisible by 5 consisting of a bunch of 

0s squeezed between two bunches of 1s} 

We know 

1) {binary numbers divisible by 5} is regular 

2) bunch of 0s squeezed between 1s is 1 * 0 * 1 * 

hence regular 

Cite closure under intersection and we’re done! 


I like closure properties!!! 

How can we get more? 


Proving new closure properties 

Method 1 

Use already derived closure properties 

Example: Closure under intersection 

We know 

1) Reg langs closed under ∪ and complement 

2) De Morgan’s laws 

If L1 and L2 are regular, so are 

C(L1) and C(L2) ..... closure under complement 

C(L1) ∪ C(L2) is regular ...... closure under ∪ 

L1∩L2 = C(C(L1) ∪ C(L2)) ..... de Morgan 

and is regular by closure under complement 


Proving new closure properties 

Method 2 

Adapt a machine 

Example: If L is regular so is L’ = {a1a3a5..a2n-1 | a1..a2n∊L} 

Let M be a DFA for L 

Define δ’(p,a) = {δ(p,ab) | 

b∊Σ} 

I extended δ:Q×Σ* → Q in the 

obvious way 

Make δ’ : 2 Q → 2 Q using union 

∀P⊆Q, δ’(P,a) = ∪p∊Pδ’(p,ab) 

F’ is subsets of Q containing 

a state of F 

M’ = (Q,Σ,δ’,{q0},F’) is an NFA for L’ 

Proof ? 

Prove by induction on n that 

δ’(P,a1..an) = ∪q∊P{δ(q,a1b1a2b2..bn-1anbn) | bi∊Σ} 

Clearly if n=0, δ’(P,ε)={δ(q,ε) | q∊P}=P 

Assume ind.hyp. true ∀i

Short Diversion 

The regular languages are NOT closed under 

“subset” 

If L1 is regular and L2 ⊂ L1 it is not necessarily true 

that L2 is regular 

The regular languages are not closed under “infinite 

union” 

If L1,L2,...,Li,... are regular it is not necessarily the 

case that L1∪L2∪...∪Li∪... is regular 


Sipser Problem 1.42 

A,B regular with DFAs MA,MB 

Show regular SHUFFLE(A,B) = 

{w=a1b1..akbk | a1..ak∊A, b1..bk∊B, each ai,bi ∊ Σ * } 

Q=QA×QB, q0=(qA0,qB0), F=FA×FB 

δ((qA,qB),a) = {(δA(qA,a),qB), (qA,δ(qB,a))} 


Another example 

If L is regular, so is 

Cycle(L) = {a2a1a4a3..a2na2n-1 | a1a2a3a4..a2n-1a2n ∊ L} 

Let M be a DFA for L. 

M’ will be a DFA for Cycle(L) that uses a state to “remember” what symbol (a) it just 

read. 

Then, when it reads the next symbol b, M’ will simulate M on input ba. Formally 

Q’ = Q ∪ (Q×Σ) 

δ’(q,a) = (q,a) 

δ’((q,a),b) = δ(q,ba) 

Prove by induction on n that 

δ’(q,a2a1a4a3..a2na2n-1) = δ(q,a1a2a3a4..a2n-1a2n) 

Clearly true when n=0 since δ’(q,ε) = q = δ(q,ε) 

Assume true for n-1, so δ’(q,a2a1a4a3..a2n-2a2n-3) = δ(q,a1a2a3a4..a2n-3a2n-2) = p, say 

Then δ’(q,a2a1a4a3..a2na2n-1) = δ’(δ’(q,a2a1a4a3..a2n-2a2n-3), a2na2n-1) 

= δ(p, a2n-1a2n) = δ(δ(q,a1a2a3a4..a2n-3a2n-2), a2n-1a2n) = δ(q,a1a2a3a4..a2n-1a2n) 

We have proved that a2a1a4a3..a2na2n-1 is accepted by M’ if and only if 

a1a2a3a4..a2n-1a2n is accepted by M. So Cycle(L) = L(M’) is regular. 


Similar examples 

Under which of these are reg langs closed? 

MAX(L) = {x∊L | xy ∊ L ⇒ y=ε} 

MIN(L) = {x∊L | (x=yz and y∊L) ⇒ z=ε} 

INIT(L) = {x∊L | ∃y and xy∊L} 

SQRT(L) = {x | for some y with |y|=|x| 2 xy∊L} 


Similar examples 

MAX(L) = {x∊L | xy ∊ L ⇒ y=ε} 

What is MAX(1*0*1)? 


Quotient of languages 

If L1 and L2 are languages then 

L1/L2 = {x | ∃y∊L2 such that xy∊L1} 

It’s true that if L1 and L2 are regular so is L1/L2 

But here’s a stronger result 

If L is a regular language and S is an arbitrary 

set then L/S is regular 


Proof (not effective!) 

If L is a regular language and S is an arbitrary set then L/S is regular 

Let M = (Q,Σ,δ,q0,F) be a DFA for L 

There is a DFA M’= (Q,Σ,δ,q0,F’) that accepts L/S 

M’ behaves just like M, but F’ consists of just 

those states for which ∃y∊S such that δ(q,y)∊F 

I don’t (and cannot in general) know what F’ is 

but I know it exists! 


Proving language no regular 

In general this is harder! 

We need a property that all regular languages 

possess 

And a way to show that a language does not 

possess that property 

The property: “pumpability” 


Proof (before the theorem!) 

A DFA has a finite number (say N) of states 

If a string w of length n>N is accepted then 

some state (say p) is revisited 

Let x be the prefix of w eaten on the way from q0 to p(first visit) 

Let y be the middle part of w eaten on the way from p (first visit) to p 

(second visit) 

Let z be the rest of w 

So w = xyz with |xy|≦ N, |y|>0 

xy i z is accepted by the DFA ∀i≧0 


Theorem (Pumping Lemma) 

If A is a regular language, then there is a 

number p (called the pumping length) such that 

whenever s is a string in A of length ≥ p, then s 

may be written s=xyz satisfying: 

for each i ≥ 0, xy i z ∊ A, 

|y| > 0, and 

|xy| ≤ p 


Use to prove {0 n 1 n | n≥0} not reg 

EvilOne: Oh Yes it is regular! 

Me: OK, so give me p 

EvilOne (gives me a constant p) 

Me: You’ll agree s = 0 p 1 p ∊L with length ≥ p 

EvilOne: Of course 

Me: Now you split s = xyz according to the rules 


The Battle Continues 

EvilOne must give me x=0 a , y=0 b ,z=0 p-(a+b) 1 p 

for some a≥0 and b≥1 

Me: You lose! Obviously xy 0 z = 0 a 0 p-(a+b) 1 p ∉ L 

since a+p-(a+b) = p ⇒ b=0 

and we know b>0 

EvilOne walks off with tail between legs 


L = {ww R | w ∊ (0+1) * } is not reg 

Proof: We need to give EvilOne a string in that 

cannot be pumped without leaving the language. 

Pumping must occur within p of beginning 

So choose s carefully with a beginning portion: 

that is clearly identifiable 

clearly makes s be of the required form 

breaks the defining property when it’s pumped 


Myhill-Nerode Theorem 

do by hand 

dealt with lightly in Sipser 

and then in JFLAP 

Exercise 1.51 and 1.52 

has as a consequence the 

basis of a minimization 

algorithm for DFAs 

Minimize this: 

toMinimize.jff

Lecture 3

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?