### PPT

```Theory of Computing
Lecture 22
MAS 714
Hartmut Klauck
Nondeterministic Finite Automata
• Definition:
– A nondeterministic finite automaton (NFA) is defined
like a DFA, except that there are possibly several
transitions from a pair (state, letter) [but at least one]
– For the graph this means that there are several edges
from state q labeled with letter a
– Acceptance if there is a path to an accepting state
• Note: variants include: allow ² transitions
(transition without reading) and incomplete edge
sets (input gets stuck/leads to no state)
Example
• Language that contains all strings having a 1 in
the third position from the end
A note
• There is no good `guess and check’ definition
of NFA
• One can prove that NFA cannot do all the
nondeterministic guesses at the beginning of
the computation and then just proceed
deterministically
– Reason: can store only O(1) guesses in the internal
state, which is not enough
DFA vs. NFA
• Theorem: The set of languages that can be
decided by NFA is equal to the set of regular
languages
• Proof:
• Take any NFA A. We have to find a DFA that
decides the same language as A
• Idea: power-set construction:
– use one state for every nonempty subset of states of A
– After reading a string x the DFA will be in the state
that the set of reachable states of A (on x)
Proof
• A has s states, simulating DFA M has 2s -1 states
• Starting state: {q0}
• Accepting states of M: those that contain an accepting
state of A
• Edges: Consider a state {q1,…, qk} of M. There is an
edge labeled with letter a to the state which is the
union of the ±(qi,a) for i=1…k
• Claim: The computation in M on input x ends in the
state s that is the set of states in A that can be reached
on x
– Proof by induction
• Then: M accepts x iff A accepts x
DFA vs. NFA
• Hence every language L decided by an NFA is
regular, and there is a DFA for L that is at most
exponentially larger than the smallest NFA
• This is also best possible
• Note that the size (number of states) of the
NFA/DFA is a constant (independent of the
input length)
Languages that are not regular
• Intuitively, DFA cannot count
• We will see that languages like {0n1n :n is a
natural number} are not regular
• To show this we simulate DFA by a
communication game
• Game is equivalent to the Myhill-Nerode method
• Most common approach: pumping lemma
– much less general
The game
•
•
•
•
Two players, Alice and Bob
Alice sends a message to Bob, who decides
whether x±y2 L
– ±: concatenation, we will also just write xy
• Cost of the game: number of messages used
Example
•
•
•
•
L={0n1n: n is natural}
How many messages are needed?
Alice has an input x
If x contains a 1 before a 0, or x=0n1n+k she sends the
message `reject’
• Otherwise 2 cases:
– Alice has 0k: she sends the message `0,k’
– Alice has 0n1k: she sends the message `1,n-k’
• Bob can decide if xy is in L from the message and y
• These are infinitely many different messages!
• We can still count the number of messages as a function of
the input length m, number of different messages is O(m)
Example 2
• Parity={w: w has odd number of 1’s}
• Alice sends the number of 1’s in her part of
the input modulo 2
• 2 messages: 0/1
• Bob accepts if the message bit is different
from the number of 1’s in his input modulo2
Example 3
• L={w: third last symbol of w is 1},
alphabet={0,1}
• Alice sends last 3 symbols of her input x (if
possible)
• Otherwise:
– If x=ab, she sends the message for 0ab
– If x=a she sends message for 00a
– If x is the empty string she sends 000
• Total: 8 messages
Example 3
• L={w: third last symbol of w is 1},
alphabet={0,1}
• Correctness of the protocol:
– Given message abc Bob can append his input y
and check if the third last symbol of abcy is 1
– If Alice’s input has length 1 or 2 then ab=00 resp.
a=0
• DFA with 8 states exists (see next theorem)
– Will show later: no DFA for L has less than 8 states
DFA and the game
• Theorem [DFA vs. game]:
– If L is regular, then the optimal number of
messages in the game is equal to the smallest
number of states in a DFA.
– If L is not regular, then the smallest number of
messages is infinite
Application
• How to show that we need many messages?
• Consider the infinite matrix M, rows labeled
with all possible x and columns labeled with
all possible y and M[x,y]=1 iff xy2 L
• Call this matrix the communication matrix of L
• Lemma: The minimum number of messages in
the game is equal to the number of distinct
rows in the matrix
Proof
• Two rows labeled x, x’ are distinct if there is a
column y where M[x,y]=1 and M[x’,y]=0
– or vice versa
• If Alice sends the same message on x and x’
then Bob cannot distinguish them, so there is
an error either on xy or on x’y
• On the other hand it is enough for Alice to
send the same message on x, x’ if they their
rows are not distinct
Examples
• Parity: M has only two distinct rows
• {0n 1n}:
– Consider the rows of M labeled 0k for all k=1,…,1
– The rows are all different [the row for 0k has a 1 only
in column 1k]
• Conclusion: {0n 1n: n natural} is not a regular
language
Example
• {w: third last symbol of w is 1}
• Consider the rows labelled by all strings of
length 3 over {0,1}
– 8 such rows
• Easy to see that these rows are all distinct
• Hence no DFA for the language can have less
than 8 states
```