Finite Autometa PDF
Finite Autometa PDF
1
Finite Automaton (FA)
• Informally, a state diagram that comprehensively captures all possible states and
transitions that a machine can take while responding to a stream or sequence of
input symbols
• Recognizer for “Regular Languages”
2
Deterministic Finite Automata - Definition
• A Deterministic Finite Automaton (DFA) consists of:
• Q ==> a finite set of states
• ∑ ==> a finite set of input symbols (alphabet)
• q0 ==> a start state
• F ==> set of accepting states
• δ ==> a transition function, which is a mapping between Q x ∑ ==> Q
• A DFA is defined by the 5-tuple:
• {Q, ∑ , q0,F, δ }
3
What does a DFA do on reading an input
string?
• Input: a word w in ∑*
• Question: Is w acceptable by the DFA?
• Steps:
• Start at the “start state” q0
• For every input symbol in the sequence w do
• Compute the next state from the current state, given the current input symbol in w and
the transition function
• If after all symbols in w are consumed, the current state is one of the
accepting states (F) then accept w;
• Otherwise, reject w.
4
Regular Languages
• Let L(A) be a language recognized by a DFA A.
• Then L(A) is called a “Regular Language”.
5
The Chomsky Hierachy
• A containment hierarchy of classes of formal languages
Regular Context-
(DFA) free Context-
Recursively-
(PDA) sensitive
enumerable
(LBA)
(TM)
6
Example #1
• Build a DFA for the following language:
• L = {w | w is a binary string that contains 01 as a substring}
• Steps for building a DFA to recognize L:
• ∑ = {0,1}
• Decide on the states: Q
• Designate start state and final state(s)
• δ: Decide on the transitions:
• “Final” states == same as “accepting states”
• Other states == same as “non-accepting states”
7
Regular expression: (0+1)*01(0+1)*
1 0,1 • ∑ = {0,1}
0
• start state = q0
start 0 1
q0 q1 q2 • F = {q2}
Accepting • Transition table
state symbols
0 1
q0 q1 q0
• What if the language allows
states
q1 q1 q2
empty strings? *q2 q2 q2
8
Example #2
Clamping Logic:
• A clamping circuit waits for a ”1” input, and turns on forever. However, to avoid clamping on
spurious noise, we’ll design a DFA that waits for two consecutive 1s in a row before clamping
on.
• Build a DFA for the following language:
L = { w | w is a bit string which contains the substring 11}
• State Design:
• q0 : start state (initially off), also means the most recent input was not a 1
• q1: has never seen 11 but the most recent input was a 1
• q2: has seen 11 at least once
9
Example #3
• Build a DFA for the following language:
L = { w | w is a binary string that has even number of 1s and even
number of 0s}
•?
10
Extension of transitions (δ) to Paths (δ)
• δ (q,w) = destination state from state q on input string w
• δ (q,wa) = δ (δ(q,w), a)
• δ (q0,wa) = ?
11
Language of a DFA
A DFA A accepts string w if there is a path from q0 to an accepting (or
final) state that is labeled by w
12
Non-deterministic Finite Automata (NFA)
• A Non-deterministic Finite Automaton (NFA)
• is of course “non-deterministic”
• Implying that the machine can exist in more than one state at the same time
• Transitions could be non-deterministic
1 qj
qi … • Each transition function therefore
1 maps to a set of states
qk
13
Non-deterministic Finite Automata (NFA)
• A Non-deterministic Finite Automaton (NFA) consists of:
• Q ==> a finite set of states
• ∑ ==> a finite set of input symbols (alphabet)
• q0 ==> a start state
• F ==> set of accepting states
• δ ==> a transition function, which is a mapping between Q x ∑ ==> subset of
Q
• An NFA is also defined by the 5-tuple:
• {Q, ∑ , q0,F, δ }
14
How to use an NFA?
• Input: a word w in ∑*
• Question: Is w acceptable by the NFA?
• Steps:
• Start at the “start state” q0
• For every input symbol in the sequence w do
• Determine all possible next states from all current states, given the current input symbol in w and
the transition function
• If after all symbols in w are consumed and if at least one of the current states is a final state
then accept w;
• Otherwise, reject w.
15
Regular expression: (0+1)*01(0+1)*
states
an input of 0 is received? q1 Φ {q2}
*q2 {q2} {q2}
16
What is an “error state”?
• A DFA for recognizing the key word “while”
w h i l e
q0 q1 q2 q3 q4 q5
w h i l e
q0 q1 q2 q3 q4 q5
18
Extension of δ to NFA Paths
• Basis: δ (q,) = {q}
• Induction:
• Let δ (q0,w) = {p1,p2…,pk}
• δ (pi,a) = Si for i=1,2...,k
• Then, δ (q0,wa) = S1 U S2 U … U Sk
19
Language of an NFA
• An NFA accepts w if there exists at least one path from the start state
to an accepting (or final) state that is labeled by w
• L(N) = { w | δ(q0,w) ∩ F ≠ Φ }
20
Advantages & Caveats for NFA
• Great for modeling regular expressions
• String processing - e.g., grep, lexical analyzer
21
But, DFAs and NFAs are equivalent in their power to capture langauges !!
Differences: DFA vs. NFA
• DFA • NFA
1. All transitions are deterministic 1. Some transitions could be non-deterministic
• Each transition leads to exactly one state • A transition could lead to a subset of states
2. For each state, transition on all possible 2. Not all symbol transitions need to be defined
symbols (alphabet) should be defined explicitly (if undefined will go to an error state –
this is just a design convenience, not to be
3. Accepts input if the last state visited is in F confused with “non-determinism”)
4. Sometimes harder to construct because of the 3. Accepts input if one of the last states is in F
number of states
4. Generally easier than a DFA to construct
5. Practical implementation is feasible
5. Practical implementations limited but emerging
(e.g., Micron automata processor)
22
Equivalence of DFA & NFA
• Theorem:
• A language L is accepted by a DFA if and only if it is accepted by an NFA.
Should be
• Proof:
true for any
L
1. If part:
• Prove by showing every NFA can be converted to an equivalent DFA (in the next few
slides…)
23
Proof for the if-part
• If-part: A language L is accepted by a DFA if it is accepted by an NFA
• rephrasing…
• Given any NFA N, we can construct a DFA D such that L(N)=L(D)
• How to convert an NFA into a DFA?
• Observation: In an NFA, each transition maps to a subset of states
• Idea: Represent:
each “subset of NFA_states” a single “DFA_state”
Subset construction
24
NFA to DFA by subset construction
• Let N = {QN,∑,δN,q0,FN}
• Goal: Build D={QD,∑,δD,{q0},FD} s.t. L(D)=L(N)
• Construction:
1. QD= all subsets of QN (i.e., power set)
2. FD=set of subsets S of QN s.t. S∩FN≠Φ
3. δD: for each subset S of QN and for each input symbol a in ∑:
• δD(S,a) = U δN(p,a)
p in s
25
Idea: To avoid enumerating all of
power set, do
“lazy creation of states”
NFA to DFA construction: Example
• L = {w | w ends in 01}
1 0
NFA: DFA: 0 1
0,1 [q0] [q0,q1] [q0,q2]
0
0 1 1
q0 q1 q2
δD 0 1 δD 0 1
δN 0 1
Ø Ø Ø [q0] [q0,q1] [q0]
q0 {q0,q1} {q0} [q0] {q0,q1} {q0} [q0,q1] [q0,q1] [q0,q2]
q1 Ø {q2} [q1] Ø {q2} *[q0,q2] [q0,q1] [q0]
*q2 Ø Ø *[q2] Ø Ø
[q0,q1] {q0,q1} {q0,q2}
*[q0,q2] {q0,q1} {q0} 0. Enumerate all possible subsets
*[q1,q2] Ø {q2} 1. Determine transitions
*[q0,q1,q2] {q0,q1} {q0,q2} 2. Retain only those states
reachable from {q0}
26
NFA to DFA: Repeating the example using LAZY
CREATION
• L = {w | w ends in 01}
1 0
NFA: DFA: 0 1
0,1 [q0] [q0,q1] [q0,q2]
0
0 1 1
q0 q1 q2
δN 0 1 δD 0 1
q0 {q0,q1} {q0} [q0] [q0,q1] [q0]
q1 Ø {q2} [q0,q1] [q0,q1] [q0,q2]
*q2 Ø Ø *[q0,q2] [q0,q1] [q0]
Main Idea:
Introduce states as you go
(on a need basis)
27
Correctness of subset construction
28
A bad case where #states(DFA)>>#states(NFA)
• L = {w | w is a binary string s.t., the kth symbol from its end is a 1}
29
Applications
• Text indexing
• inverted indexing
• For each unique word in the database, store all locations that contain it using
an NFA or a DFA
• Find pattern P in text T
• Example: Google querying
• Extensions of this idea:
• PATRICIA tree, suffix tree
30
A few subtle properties of DFAs and NFAs
• The machine never really terminates.
• It is always waiting for the next input symbol or making transitions.
• The machine decides when to consume the next symbol from the input and when to ignore it.
• (but the machine can never skip a symbol)
• => A transition can happen even without really consuming an input symbol (think of consuming
as a free token) – if this happens, then it becomes an -NFA (see next few slides).
• A single transition cannot consume more than one (non-) symbol.
31
FA with -Transitions
• We can allow explicit -transitions in finite automata
• i.e., a transition from one state to another state without consuming any
additional input symbol
• Explicit -transitions between different states introduce non-determinism.
• Makes it easier sometimes to construct NFAs
Definition: -NFAs are those NFAs with at least one explicit -
transition defined.
• -NFAs have one more column in their transition table
32
Example of an -NFA
L = {w | w is empty, or if non-empty will end in 01}
0,1
0 1
• -closure of a state q,
q0 q1 q2 ECLOSE(q), is the set of all
states (including itself) that
start q’0 can be reached from q by
repeatedly making an
arbitrary number of -
δE 0 1
transitions.
ECLOSE(q’0)
*q’0 Ø Ø {q’0,q0}
q0 {q0,q1} {q0} {q0} ECLOSE(q0)
q1 Ø {q2} {q1} ECLOSE(q1)
0,1
Simulate for w=101:
0 1
q0 q1 q2
q0’
start q’0
q 0’ q0
1 1
q0
δE 0 1 Ø
x 0
ECLOSE(q’0)
*q’0 Ø Ø {q’0,q0} q1
q0 {q0,q1} {q0} {q0} ECLOSE(q0) 1
q1 Ø {q2} {q1} q2
*q2 Ø Ø {q2} 34
To simulate any transition:
Step 1) Go to all immediate destination states.
Step 2) From there go to all their -closure states as well.
Example of another -NFA
0,1 Simulate for w=101:
?
0 1
q0 q1 q2
1
start q’0 q3
δE 0 1
*q’0 Ø Ø {q’0,q0,q3}
q0 {q0,q1} {q0} {q0,q3}
q1 Ø {q2} {q1}
*q2 Ø Ø {q2}
q3 Ø {q2} {q3}
35
Equivalency of DFA, NFA, -NFA
• Theorem: A language L is accepted by some -NFA if and only if L is
accepted by some DFA
• Implication:
• DFA ≡ NFA ≡ -NFA
• (all accept Regular Languages)
36
Eliminating -transitions
Let E = {QE,∑,δE,q0,FE} be an -NFA
Goal: To build DFA D={QD,∑,δD,{qD},FD} s.t. L(D)=L(E)
Construction:
1. QD= all reachable subsets of QE factoring in -closures
2. qD = ECLOSE(q0)
3. FD=subsets S in QD s.t. S∩FE≠Φ
4. δD: for each subset S of QE and for each input symbol a∑:
• Let R= U δE(p,a) // go to destination states
0,1
0 1
q0 q1 q2
start q’0
δE 0 1
δD 0 1
0,1 0
0
0 1 {q0,q1}
q0 q1 q2 0 1 {q0,q2}
0
1
start start {q’0, q0} 1
q’0 q0 1
ECLOSE union
δE 0 1
δD 0 1
40