Pumping Lemma für reguläre Sprachen

FORMAL LANGUAGES, AUTOMATA, AND

COMPUTABILITY

15-453

Q Σ q₀ F

M = ({p,q}, {0,1}, , p, {q}) ^{ 0 1}

p p q

q q p

0

1 1

0

p q

THEOREM:

L(M) = {w | w has odd

number of 1s }

Induction Step: Suppose for all w  Σ*, |w| = n, w  L(M) if w has odd number of 1s Any string of length n+1 has the form w0 or w1

If w has odd # of 1’s, M is in state q after reading w

 M is in state p after reading w1  M rejects w1

 M is in state q after reading w0  M accepts w0 Proof: By induction on n, the length of a string.

Base Case: n=0: ε  L and ε  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

“Regular Languages Are Closed Under Union”

Complement THEOREM

The complement of a regular

language 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: A^R = { w₁ …w_k | w_k …w₁  A }

Concatenation: A  B = { vw | v  A and w  B } Star: A* = { s₁ … s_k | k ≥ 0 and each s_i  A }

REVERSE THEOREM

The reverse of a regular language is also a regular language

``Regular Languages Are Closed Under Reverse”

If a language can be recognized by a DFA that reads strings from right to left,

then there is an “normal” DFA that accepts the same language

Counterintuitive! DFAs have finite memory…

REVERSING DFAs

Assume L is a regular language.

Let M be a DFA that recognizes L

We’ll build a machine M^R that accepts L^R If M accepts w, then w describes a

directed path in M from start to an accept First Attempt: Try to define M^R as M with the arrows reversed, turn start state into a final state, turn final states into starts

M

IS NOT ALWAYS A DFA!

It could have many start states Some states may have too

many outgoing edges, or none at all!

1 0

1

0 1

0,1

0

NON DETERMINISM

1 0

1

0 1

0,1

0

What happens with 100?

We will say that this machine accepts a string if there is some path that reaches an accept state

from a start state

IBM JOURNAL APRIL 1959 Turing Award winning paper

0,1

0, ε 0

0,1

At each state, we can have any number of out arrows for some letter   Σ, including ε

NFA EXAMPLES

1

ε 0

1 0,1

0

Possibly many start states

NFA EXAMPLES

L(M) = {0

1

| i  {0,1}, j ≥ 0}

1

0

0

L(M)={1,00}

NFA EXAMPLES

Q is the set of states Σ is the alphabet

 : Q  Σ_ε → 2^Q is the transition function Q₀  Q is the set of start states

F  Q is the set of accept states

A non-deterministic finite automaton (NFA) is a 5-tuple N = (Q, Σ, , Q₀, F)

2^Q is the set of all possible subsets of Q Σ_ε = Σ  {ε}

Let w Σ* and suppose w can be written as w₁... w_n where w_i  Σ_ε (ε = empty string)

Then N accepts w if there are r₀, r₁, ..., r_n  Q

such that

• r₀  Q₀

• r_i+1  (r_i, w_i+1 ) for i = 0, ..., n-1, and

• r_n  F

A language L is recognized by an NFA N if L = L(N).

L(N) = the language recognized by N

= set of all strings machine N accepts

1

0

0

(q₃,1) = q₁

q₂

q₃

q₄

N = (Q, Σ, , Q₀, F) Q = {q₁, q₂, q₃, q₄}

Σ = {0,1}

Q₀ = {q₁, q₂} F = {q₄}  Q

(q₂,1) = {q₄}

 ε

(q₁,0) = { q3} 00  L(N)?

01  L(N)?

Deterministic Computation

Non-Deterministic Computation

accept or reject accept

reject

MULTIPLE START STATES

We allow multiple start states for NFAs,

Can easily convert NFA with many start states into one with a single start state:

ε ε ε

UNION THEOREM FOR NFAs?

0 0

1 1

0

NFAs ARE SIMPLER THAN DFAs

An NFA that recognizes the language {1}:

1

1 0,1

0 0,1 A DFA that recognizes the language {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 L^R is regular

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

BUT DFAs CAN SIMULATE NFAs!

FROM NFA TO DFA

Input: N = (Q, Σ, , Q₀, F)

Output: M = (Q, Σ, , q₀, F)

accept

reject

To learn if NFA accepts, we could do the computation in parallel, maintaining the

set of all possible states that can be reached

Q = 2

Q = 2^Q

Q = 2^Q

 : Q  Σ →

Q(R,) =



rR

q₀ = ε(Q₀)

F = { R  Q | f  R for some f  F }

FROM NFA TO DFA

Input: NFA N = (Q, Σ, , Q₀, F)

Output: DFA M = (Q, Σ, , q₀, 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}

*

0,1

0,ε 0,ε

0,1

EXAMPLE OF ε-CLOSURE

q₀ q₁ q₂

ε({q₀}) = {q₀ , q₁, q₂} ε({q₁}) = {q₁, q₂}

ε({q₂}) = {q₂}

a

a , b

a

2 3

1 b

ε

Given: NFA N = ( {1,2,3}, {a,b},  , {1}, {1} ) Construct: Equivalent DFA M

ε({1}) = {1,3}

N

M = (2^{1,2,3}, {a,b}, , {1,3}, …) {1,3}

a

b

{2} a {2,3}

b

{3}

a

{1,2,3}

b a b

a 

a,b

{1}, {1,2} ?

b

NFAs CAN MAKE PROOFS MUCH

EASIER!

Remember this on your Homework!

REGULAR LANGUAGES ARE CLOSED UNDER 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: A^R = { w₁ …w_k | w_k …w₁  A }

Concatenation: A  B = { vw | v  A and w  B } Star: A* = { w₁ …w_k | k ≥ 0 and each w_i  A }

SOME LANGUAGES ARE NOT REGULAR

B = {0

1

| n ≥ 0} is NOT regular!

WHICH OF THESE ARE REGULAR

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

D = { w | w has equal number of

occurrences of 01 and 10 } NOT REGULAR

REGULAR!!!

THE PUMPING LEMMA

Let L be a regular language with |L| =



Then there is a positive integer P s.t.

1. |y| > 0 (y isn’t ε) 2. |xy| ≤ P

3. For every i ≥ 0, xyⁱz  L if w  L and |w| ≥ P

then can write w = xyz, where:

Why is it called the pumping lemma? The word w gets PUMPED into something longer…

z Let P be the number of states in M

Assume w  L is such that |w| ≥ P

q₀ … q_j q_k q_|w|

There must be j and k such that j < k ≤ P, and q_j = q_k

Proof: Let M be a DFA that recognizes L

1. |y| > 0 2. |xy| ≤ P

3. xyⁱz  L for all i ≥ 0 We show: w = xyz

x

y

USING THE PUMPING LEMMA

Let’s prove that

B = {0ⁿ1ⁿ | n ≥ 0} is not regular

Assume B is regular. Let w = 0^P1^P

If B is regular, can write w = xyz, |y| > 0,

|xy| ≤ P, and for any i ≥ 0, xyⁱz is also in B If y is all 0s: xyyz has more 0s than 1s

If y is all 1s: THIS CASE CAN’T HAPPEN!

If y has both 1s and 0s:

THIS CASE CAN’T HAPPEN!

|xy| ≤ P

Contradiction!

USING THE PUMPING LEMMA

Assume C is regular. Let w = 0^P1^P (w is in C!) If C is regular, can write w = xyz, |y| > 0,

|xy| ≤ P, where for any i ≥ 0, xyⁱz is also in C If y is all 0s: xyyz has more 0s than 1s If y is all 1s: CAN’T HAPPEN

If y has both 1s and 0s:

CAN’T HAPPEN C = { w | w has equal

number of 1s and 0s}

is not regular

FLAC

Read Chapters 1.3 and 2.1 of the book for next time