Conversions & Pumping Lemma

CPSC 388 Fall 2001Ellen WalkerHiram College

For every r.e. there is a DFA...

• If we can construct an NFA, that’s good enough

• Prove by induction:– Base cases: , , a (element of

) -- build an NFA for each.– Step cases: r | s , rs , r* -- build resulting NFA from NFA’s from r and/or s

Base Cases

•

• a

a

A Generic NFA

• Initial and (single) accept state– For multiple accept states, add

-transitions from all accept states to one

• Arbitrary labeled connections (and other states) as well

NFA for Concatenation (rs)

NFA for choice (r | s)

NFA for star (a*)

Completing the Proof

• Because every r.e. can be constructed from basic r.e. (and each has an NFA)

• And there are only 3 ways to combine r.e.’s (and we have NFA for each)

• Therefore, we can create an NFA for every regular expression

From DFA to R.E.

• Every expression that a DFA accepts is represented by a path from an initial state to an accept state

• If there are intermediate states, they can be deleted and represented by the r.e.’s necessary to get past them.

R.E. from 2-state DFA

s

t

r

v

This DFA accepts (r+ts*v)*ts*

(Consider all paths from initial to final)

Extending to Larger DFA’s

• For any state that is neither initial nor final, compute r.e. for each path *through* the state

• Replace the state by links labeled with the full regular expressions

• Repeat until all states are initial or final, then make a choice of all paths

Now find the expression for...

• All strings that do not contain the sequence “ab”

• Use – R.E. -> NFA for not-L ((a+b)*ab(a+b)*)

– NFA -> DFA– Swap accept vs. not accept states (for L)

– DFA -> R.E.

A Regular Grammar

• A regular grammar is a grammar with all rules of the form– X -> a– X -> aY (left linear rule)– X -> Ya (right linear rule)

• Either left-linear or right-linear rules may be used, but not both in the same grammar

Left-linear Grammar to NFA

• X -> a– a-transition from X to accept state– (a can be )

• X -> aY– a-transition from X to Y – (Y can be X)

• Use the same idea to take NFA to grammar!

A non-regular language

• All strings of the form a*b* where the number of a’s is equal to the number of b’s– This language requires a way of keeping track of how many a’s we’ve seen -- but the only way we can keep track is by the number of states!

Proving a Language Non-Regular

• “I tried real hard and couldn’t come up with a DFA, NFA, or regular expression…” -- not a proof!

• “There is a property that all regular languages have that this one doesn’t…” -- now that’s a proof

Long Strings Need Loops

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

• If we have N (or more) characters in a string, we must have visited one of the states twice within the first N-1 chars.

• Therefore, there must be a loop.– Therefore, we can repeat part of the string an arbitrary # of times (including 0)

A Pumping Lemma

• Every string that is accepted by a DFA and is longer than N (number of states) can be divided into 3 parts (xyz), where– The length of xy ≤ N– The length of y>0– The strings xz, xyyz, xyyyz, etc. are also in the language

• (i.e. “y” is the part accepted by the loop)

Using the Pumping Lemma

• Pick a string in the language that is longer than N

• Show that there is no way to divide it up according to the rules of the lemma

• Therefore, by contradiction, the language cannot be regular

An example: a*b*, #a’s = #b’s

1. Assume it’s regular. Pick the string with N a’s and N b’s

2. Since |xy| ≤ N, y must have all a’s

3. “Pumping” xyyz has too many a’s4. But the pumping lemma said that string had to be in the language.

5. We have a contradiction, so the language is not regular.

Notes on applying the pumping lemma

• It only has to fail for one string in the language

• (But…) It has to fail for all legal assignments of xyz

• Sometimes it’s easier to “pump down” to xz instead of “pumping up” to xyyz

L= a* where the number of a’s is square

1. Assume the language is regular. Pick the string of N2 a’s

2. If we divide it we have |xy| ≤ N3. xyyz is at most (N2+N) a’s.4. But, the next biggest square is N2+N+1 (so this string cannot be accepted)!

5. So the pumping lemma doesn’t hold, so the language is not regular.

Proving a language...

• Regular:– Give a regular expression– Give a finite automaton (NFA or DFA)

– Create a regular grammar

• Non-Regular:– Proof by contradiction using the pumping lemma