1. Instructor: Aaron Roth aaroth@cis.upenn.edu
CIS 262 Automata, Computability, and Complexity Spring
Instructor: Aaron Roth
Lecture: February 6, 2019

2. Course Logistics Homework 2 is out.
Due Wednesday February 20 before class, turned in via GradeScope.

3. Nondeterministic Automata
In state q0, on symbol a, choice of next state is not unique: either q0 or q1
In state q2 cannot process additional symbols (no next state)
Deterministic transition function: processing symbol s in state q leads to the unique next state d(q, s)
Nondeterministic transition function D maps a state and a symbol to a set of states: if current state is q and symbol is s, next state is chosen from the set D(q, s)
a,b a
a, b q0 q1 q2

4. Execution of Nondeterministic Automata
a,b q0 a
a, b a q0 q1 q2 q0 q1 b
How does the machine process input string abab ?
Many possible executions/runs corresponding paths in this tree
Successful run:
All of input processed, and
Resulting state is accepting
Input accepted if at least one of the runs is successful q0 q2 a q0 q1 b q0 q2

5. Execution of Nondeterministic Automata
a,b q0 a
a, b a q0 q1 q2 q0 q1 a
How does the machine process input string aabb ?
Input rejected if no run is successful q0 q1 q2 b q0 q2 b q0

6. Language of a Nondeterministic Automaton
NFA M accepts a string w if and only if there exists a successful execution of M on w
Which strings does the above machine accept ?
L(M) = { w | second last symbol of w equal a }
a,b a
a, b q0 q1 q2

7. NFA Example
S = { A, C, G, T }
A, C, G,T
A,C, G,T A C C q0 q1 q2 q3
Nondeterministic transition function D : Q x S  2Q
D(q0, A) = {q0 , q1}; D(q0, C) = {q0}; D(q1, A) = { }; …
What language does this NFA accept ?

8. NFA Example
S = { A, C, G, T }
A, C, G,T
A,C, G,T A C C q0 q1 q2 q3
Execution of the machine on input ACTACCGA:
Alternative to tree of all possible runs: compute the set of possible states after processing each input symbol A
{q0 , q1 } C
{q0 , q2 } T
{q0 } A
{q0 , q1 }
{ q0 } C
{q0 , q2 } C
{q0 , q3 } G
{q0 , q3 } A
{q0 , q1 , q3}
Accept input if the set of possible states at the end contains a final state

9. Definition: NFA Syntax
A nondeterministic finite automaton (NFA) M consists of
a finite set Q of states
a finite alphabet S
an initial state q0 that belongs to Q
a subset F of Q, called accepting/final states
a transition function D : Q x S  2Q
(if M reads symbol s in state q, the resulting state is some state chosen from the set D(q, s) )

10. Definition: NFA Semantics
Let M = (Q, S, q0, F, D) be an NFA.
M accepts the string w = w1 w2 … wk
if there exists a sequence of states q0 q1 q2 … qk such that
(1) q0 is the initial state,
(2) for each i=0, 1, … (k-1), state qi+1 is in D(qi, wi+1), and
(3) state qk is in F.
L(M) = set of strings w such that M accepts w

11. Alternative Definition of Acceptance
Let M = (Q, S, q0, F, D) be an NFA.
Define extended transition function D* : Q x S*  2Q
D *(q, w) = set of all possible states where machine can be after processing the string w starting in state q
D*(q, e) = { q }
D*(q, x. s) = U D(q’, s)
M accepts the input w if and only if the intersection of the sets D*(q0, w) and F is non-empty
q’ in D*(q,x)

12. NFA Example Which strings does the above machine accept ?
L(M) = { w | second last symbol of w equal a }
a,b a
a, b
a, b q0 q1 q2 q3

13. NFA Example
Draw an NFA that accepts { w | third last symbol of w equal a }
Recall: A DFA for this language must have 8 states q0 q1 a
a, b q2
a,b q3

14. Parametric Example
= {a, b}. For each k, let Lk = { w | kth symbol from end in w equals a }
How many states does an NFA need to accept Lk as a function of k ? a
a,b
a, b
k-1 transitions
NFA with (k+1) states can accept Lk
Recall: DFA must have 2k states
Nondeterminism can lead to succinct descriptions !

15. Nondeterminism as a high-level constructq0 q1
In state q0, on reading symbol a, how does the machine know whether to stay in state q0 or go to state q1?
One answer: if only of the two possibilities is going to lead to success at the end, then it chooses that
A real-world machine/program cannot figure out which possibility is going to succeed, so needs to track all possibilities by maintaining a set of possible current states
Nondeterminism is a “logical” or “mathematical” construct with no direct analog in the real world

16. Why Study Nondeterminism ?
If there is no “real-world” analog of nondeterminism construct, namely, make the choice that will lead to success, why bother?
First, excellent test case for studying “models of computation”
Mathematically well-defined syntax and semantics
Valid mathematical question: how does this construct impact computational power
Second, turns out to be very important concept
Useful in translation from regular expressions
Critical to theory of NP-complete problems which includes a large number of natural optimization problems

17. Does nondeterminism always help ?
Draw an NFA that accepts L = { w | count(w,a) is even }
DFA for this language:
DFAs are a special case of NFAs
Above machine is also an NFA for L
Is there a smaller/simpler NFA for L ? q0 q1 a b

18. NFA Example
S = { A, C, G, T } Draw NFA for { w | w contains “ACCAC” as a substring }
A, C, G,T
A,C, G,T A C A C C q0 q1 q2 q3 q4 q5
If input w contains the substring ACCAC then some run does end up in final state q5
If a run does end up in state q5, then w must contain “ACCAC”

19. NFA Example
S = { A, C, G, T } Draw NFA for { w | w contains “ACCAC” as a substring or ends with G }
A, C, G,T
A,C, G,T C A C A C q0 q1 q2 q3 q4 q5 G q6

20. Can we design NFAs when there is no DFA ?
L = { w | count(w,a) = count(w,b) }, where S = { a, b }
We know that L is not regular, that is, there is no DFA for L
Can we construct an NFA for L ?
Why did DFA construction fail?
Strings 𝜖, a, aa, aaa, a4, … all need to lead to “distinct” states
Can non-determinism help?
More generally, are NFAs “more expressive” than DFAs?
Is there an NFA M such that L(M) is not regular?

21. Compiling an NFA to a DFA
Let M = (Q, S, q0, F, D) be an NFA.
Goal: to construct a DFA M’ such that M’ accepts w if and only M does
How can a deterministic machine track information about all possible executions of M ?

22. Recap: Set-based Definition of NFA Execution
S = { A, C, G, T }
A, C, G,T
A,C, G,T A C C q0 q1 q2 q3
Execution of the machine on input ACTACCGA:
{ q0 } A
{q0 , q1 } C
{q0 , q2 } T
{q0 }
{q0 , q3 } G
{q0 , q1 , q3}
To simulate an NFA M, the DFA M’ maintains, as its state, the set of states of M

23. From NFA to DFA: Subset Construction
A, C, G,T
A,C, G,T C A C q0 q1 q2 q3
C, G,T A A A C
{ q0 }
{ q0 , q1 }
{ q0 , q2 } C
G, T T G
Only finitely many states can be generated: all possible subsets of {q0 , q1 , q2 , q3 } suffice

24. NFA => DFA Let M = (Q, S, q0, F, D) be an NFA.
Goal: to construct a DFA M’ such that M’ accepts w if and only M does
A state of M’ is a set of states of M: Q’ = 2Q
Initial state q’0 of M’ = { q0 }
A state is final for M’ if it contains a final state of M:
F’ = { S | intersection of S and F is non-empty }
Transition function of M’: d’( S, s) = U D(q, s)
This construction is called “determinization” or “subset construction”
q in S

25. Correctness of Determinization
Let M = (Q, S, q0, F, D) be an NFA.
Consider the DFA M’ = (2Q, S , { q0 } , F’, d’), where
F’ = { S | intersection of S and F is non-empty } and
d’( S, s) = U D(q, s)
Prove: L(M) = L(M’)
To prove: for all strings w, NFA M accepts w iff DFA M’ accepts w
What’s the suitable claim that can be proved by induction on w ?
For all strings w, D*(q0 , w) = d’ *({ q0 }, w)
that is, the set of states that NFA M can be after processing a string w coincides with the state of DFA M’ after processing w
q in S

26. Example of Determinization
a,b b
{ }
{ q0 }
a,b
a,b a b a q0 q1
{ q1 }
{ q0 , q1 } a
In above automatically constructed DFA, states { } and {q1} are redundant, since they are “unreachable” from the initial state {q0}
Possible optimization: Construct only those states that are reachable from the initial state {q0}

27. Summary of Determinization
For every NFA, there exists an equivalent DFA accepting same language
The class of problems solved by DFAs and NFAs is identical, namely, regular languages
It is straightforward to write a computer program that implements the NFA to DFA translation
If NFA M has k states then the determinized machine M’ has 2k states
Some optimizations can result in smaller DFAs in some cases, but such an exponential blow-up is unavoidable in worst-case, for example, Lk = {w | kth symbol from end equals a } has NFA with k+1 states, but every DFA for this language must have at least 2k states

28. Nondeterministic Automata: Summary
NFA model is a generalization of DFA: transition function maps a state and a symbol to a set of states
Semantics: NFA accepts a string if one of the many possible executions leads to a final state
Nondeterminism does not increase expressiveness:
An NFA can be compiled into an equivalent DFA
NFAs accept only regular languages
NFAs allow more high-level or succinct descriptions

29. NFAs with e-transitions
A number consists of one or more digits 0..9 (but first digit is not 0) and can be optionally preceded by + or - q0 q1
e, +, -
1..9 q2
0..9
Meaning of e-transition: state may change without consuming any input symbol
Acceptance as before: a string is accepted as long as some execution succeeds

30. e-NFAs Transition function D : Q x [ S U { e } ]  2Q
Such transitions do not increase expressiveness:
An NFA with e-transitions can be compiled into an equivalent DFA by modifying the subset construction
e-transitions can allow more natural/succinct description
Read the textbook for details