Finite Automata (contd) - Cornell University · 2014-10-23 · Non-deterministic Finite Automaton...

Finite Automata (contd)

CS 2800: Discrete Structures, Fall 2014

Sid Chaudhuri

Recap: Deterministic Finite Automaton● A DFA is a 5-tuple M = (Q, Σ, δ, q

0, F)

– Q is a fnite set of states– Σ is a fnite input alphabet (e.g. {0, 1})– δ is a transition function δ : Q × Σ → Q

– q0 ∈ Q is the start/initial state

– F ⊆ Q is the set of fnal/accepting states

Yes No1

100

A non-deterministic fnite automaton

q0

1 0,10,1 q

1 0,1q2


q0

1 0,10,1 q

1 0,1q2

Different transitionsfrom q

0 on input 1


q0

1 0,10,1 q

1 0,1q2

An NFA accepts a string x if it can getto an accepting state on input x

Different transitionsfrom q

0 on input 1


q0

1 0,10,1 q

1 0,1q2

What language does this automaton accept?


q0

1 0,10,1 q

1 0,1q2

Answer: All strings ending with 1

Another NFA

q0

1 0,10,1 q

2 0,1q3

What language does this automaton accept?

q1

0,1

Another NFA

q0

1 0,10,1 q

2 0,1q3

Answer: All strings with 1 in the penultimate place

q1

0,1

Non-deterministic Finite Automaton● An NFA is a 5-tuple M = (Q, Σ, δ, q

0, F)


0, F)

– Q is a fnite set of states

q0

q1 q

2q

3


0, F)

– Q is a fnite set of states– Σ is a fnite input alphabet (e.g. {0, 1})

q0

q1 q

2q

3

0,1


0, F)


– δ is a transition function δ : Q × Σ → 2Q

q0

q1

1 0,10,1 q2 0,1q

3

0,1


0, F)



q0

q1

1 0,10,1 q2 0,1q

3

Only changefrom DFAs

0,1


0, F)




q0

q1

1 0,10,1 q2 0,1q

3


0,1


0, F)




– F ⊆ Q is the set of fnal/accepting states

q0

q1

1 0,10,1 q2 0,1q

3


Non-deterministic Finite Automaton

● An NFA accepts a string x if it can get to an accepting state on input x


● An NFA accepts a string x if it can get to an accepting state on input x– Think of it as trying many options at once, and hoping

one path gets lucky



one path gets lucky

● A transition f (state, symbol) ↦ ∅ (the empty set) is possible



one path gets lucky

● A transition f (state, symbol) ↦ ∅ (the empty set) is possible– … in this case, the NFA treats this as a rejecting path

(the string may still reach an accepting state by another path)



one path gets lucky

● A transition f (state, symbol) ↦ ∅ (the empty set) is possible– … in this case, the NFA treats this as a rejecting path

(the string may still reach an accepting state by another path)

– A convenient shortcut for our “hell/black-hole” state


● Every DFA is an NFA


● Every DFA is an NFA– If we're strict with our notation, we need to replace the

transitionf (state

1, symbol) ↦ state

2 with

f (state1, symbol) ↦ {state

2}



transitionf (state


2 with


2}

● Every NFA can be simulated by a DFA



transitionf (state


2 with


2}

● Every NFA can be simulated by a DFA– … i.e. they accept exactly the same language



transitionf (state


2 with


2}

● Every NFA can be simulated by a DFA– … i.e. they accept exactly the same language– Exponential blowup: if the NFA has n states, the DFA

can require up to 2n states

Thought for the Day #1

Find an NFA with n states that can't be simulated by a DFA with less than 2n states

Every NFA can be simulated by a DFA


p

q

ra

a

NFA(fragment)


p

q

ra

a

{p} {q, r}a

DFA (fragment)NFA(fragment)


p

q

ra

a

{p} {q, r}a

“Subset construction”

NFA(fragment)

DFA (fragment)

(This is merely illustrative – formal construction on following slides)


NFA Equivalent DFA

Specifcation

States

Alphabet

Transition Function

Initial State

Accepting States


NFA Equivalent DFA

Specifcation (Q, Σ, δ, q0, F) (2Q, Σ, δ', q'

0, F')

States

Alphabet

Transition Function

Initial State

Accepting States


NFA Equivalent DFA


0, F')

States Q 2Q

Alphabet

Transition Function

Initial State

Accepting States


NFA Equivalent DFA


0, F')

States Q 2Q

Alphabet Σ Σ

Transition Function

Initial State

Accepting States


NFA Equivalent DFA


0, F')

States Q 2Q

Alphabet Σ Σ

Transition Function δ δ'(S, a) = ∪s ∈ S δ(s, a)

Initial State

Accepting States


NFA Equivalent DFA


0, F')

States Q 2Q

Alphabet Σ Σ


Initial State q0

q'0 = {q

0}

Accepting States


NFA Equivalent DFA


0, F')

States Q 2Q

Alphabet Σ Σ


Initial State q0

q'0 = {q

0}

Accepting States F F' = {S ∈ 2Q | S ∩ F ≠ ∅}

Why NFAs?

Why NFAs?

● They can be way more compact than DFAs

Why NFAs?


0,1

q0

q1

1

0,1

q3

q20,1

NFA

Why NFAs?


q000

q001

q010

q011

q100

q101

q110

q111

0 1 0

00

00

0

0

1

1

1

1

1

1

1

0,1

q0

q1

1

0,1

q3

q20,1

NFA Equivalent minimal DFA

Why NFAs?


● It's easier to directly convert regular expressions (“wildcard search” on steroids) to NFAs

q000

q001

q010

q011

q100

q101

q110

q111

0 1 0

00

00

0

0

1

1

1

1

1

1

1

0,1

q0

q1

1

0,1

q3

q20,1

NFA Equivalent minimal DFA

Finite automata struggle to count

● Any FA (deterministic or not) that recognizes the language {1c} (the single string of c 1's) must have more than c states– The parent alphabet is irrelevant (but must of course

contain 1)

Proof: FAs struggle to count


● Imagine there is some FA M that recognizes the language {1c} and has ≤ c states



● On input 1c, M can traverse states q0, q

1, q

2, …, q

c




1, q

2, …, q

c

– … where qc is an accepting state




1, q

2, …, q

c


● If M has ≤ c states, some state must be repeated in this sequence, say q

i = q

j with i < j




1, q

2, …, q

c



i = q

j with i < j

Pigeonhole Principle




1, q

2, …, q

c



i = q

j with i < j

– Let t = j – iPigeonhole Principle


● M can take the following steps on input 1c



1. After reading 1i, M is in state qi




2. Then it reads 1t and loops back to qj = q

i





i

3. Then it fnishes of by reading 1c – j





i


● Step 2 can be repeated indefnitely by inserting copies of 1t in the string!





i



1t





i



● So M also accepts 1c + t, 1c + 2t, 1c + 3t etc

1t





i



● So M also accepts 1c + t, 1c + 2t, 1c + 3t etc– … which is a contradiction!

1t





i



● So M also accepts 1c + t, 1c + 2t, 1c + 3t etc– … which is a contradiction!

QED

1t

q0

qc

qi = q

j

FAs struggle to count

⋅⋅⋅ ⋅⋅⋅

⋅⋅⋅1j - i

1i 1c - j

Can be repeated!

q0

qc

qi = q

j

Generalizing...

⋅⋅⋅ ⋅⋅⋅

⋅⋅⋅v

u w

Can be repeated!

Pumping Lemma

Pumping Lemma

● If M is an FA with k states

Pumping Lemma

● If M is an FA with k states● … and M accepts some string x with |x| ≥ k,

Pumping Lemma

● If M is an FA with k states● … and M accepts some string x with |x| ≥ k,● … then there exist strings u, v and w such that

Pumping Lemma


– x = uvw,

Pumping Lemma


– x = uvw,– |uv| ≤ k,

Pumping Lemma


– x = uvw,– |uv| ≤ k,– |v| ≥ 1

Pumping Lemma


– x = uvw,– |uv| ≤ k,– |v| ≥ 1

● … and uviw is accepted by M for all i ∈ N ∪ {0}

Pumping Lemma


– x = uvw,– |uv| ≤ k,– |v| ≥ 1

● … and uviw is accepted by M for all i ∈ N ∪ {0}

Exercise: Write out the proof formally!

Why is the pumping lemma useful?


● Used to prove languages cannot be recognized by any FA whatsoever



● E.g. the language with all strings of 0's concatenated with equally long strings of 1's, i.e. 0

n1

n for all n ∈ N



● E.g. the language with all strings of 0's concatenated with equally long strings of 1's, i.e. 0

n1

n for all n ∈ N

– FA's don't have unlimited “memory”, so they can't store the number of 0's they have seen

Proof: 0n1

n is not recognized by any FA

Proof: 0n1

n is not recognized by any FA● We'll prove it by contradiction

Proof: 0n1


● Assume there is some FA M with k states that accepts a string if it is of the form 0n

1n for any n ∈ N

Proof: 0n1



1n for any n ∈ N

● Consider 0k1

k, which is accepted by M

Proof: 0n1



1n for any n ∈ N

● Consider 0k1


● It's longer than k, so by the Pumping Lemma, there exist u, v, w s.t. uvw = 0

k1

k, |uv| ≤ k and |v| ≥ 1

Proof: 0n1



1n for any n ∈ N

● Consider 0k1



k1

k, |uv| ≤ k and |v| ≥ 1

– … and v must consist entirely of 0's (since |uv| ≤ k)

Proof: 0n1



1n for any n ∈ N

● Consider 0k1



k1

k, |uv| ≤ k and |v| ≥ 1


● So M accepts all strings of the form 0|u|0

i|v|0

k - |uv|1

k, such as0

|u|0

k - |uv|1

k, 0|u|0

2|v|0

k - |uv|1

k, 0|u|0

3|v|0

k - |uv|1

k etc

Proof: 0n1



1n for any n ∈ N

● Consider 0k1



k1

k, |uv| ≤ k and |v| ≥ 1



i|v|0

k - |uv|1

k, such as0

|u|0

k - |uv|1

k, 0|u|0

2|v|0

k - |uv|1

k, 0|u|0

3|v|0

k - |uv|1

k etc

– … which are not of the form 0n1

n (since |v| ≥ 1)

Proof: 0n1



1n for any n ∈ N

● Consider 0k1



k1

k, |uv| ≤ k and |v| ≥ 1



i|v|0

k - |uv|1

k, such as0

|u|0

k - |uv|1

k, 0|u|0

2|v|0

k - |uv|1

k, 0|u|0

3|v|0

k - |uv|1

k etc

– … which are not of the form 0n1

n (since |v| ≥ 1)

– … hence proved by contradiction

Finite Automata (contd) - Cornell University · 2014-10-23 · Non-deterministic Finite Automaton...

Documents

Transcript of Finite Automata (contd) - Cornell University · 2014-10-23 · Non-deterministic Finite Automaton...