University of Oslo
: Department of Informatics
Finite State Automata
Jonathon Read
9 October 2012
INF4820: Algorithms for AI and NLP
Previously
I
Regular expressions are powerful tools for describing
infinite sets of strings
I
The fundamental operations are:
I
I
I
Matching characters, wildcards (.) and anchors (ˆ and $)
Disjunction (| and [ ])
Quantification (?, *, + and {n, m})
I
Precedence can be enforced with brackets (( and ))
I
More complex operations include capturing groups
Some examples
I
/ˆa (fox|wolf)$/ ⇒ { a fox a wolf }
I
/ˆf[aio]x]$/ ⇒ { fax fix fox }
I
/ˆ(fox[ $])+/ ⇒ { fox fox fox fox fox fox }
Today
I
Describing regular expressions with finite state automata
I
Using finite state automata to process strings
I
State-space search
I
Finite state transducers
I
Applications in gaming artificial intelligence
Finite state automata (FSAs)
I
Mathematical models of computation
I
Can be in any one of a finite number of states
I
Changes state in response to triggering conditions—sets of
labelled transitions from state to state
Defining finite state automata
Jurafsky & Martin 2009
Q = {q0 , q1 , . . . , qN−1 } a finite set of N states
Σ
a finite input vocabulary
qo
the start state
F
δ q, i
the set of final states, F ⊆ Q
the transition function between
states. Given a state q ∈ Q and
an input symbol i ∈ Σ, δ q, i returns a new state q0 ∈ Q
Sheeptalk
/baa+!/ ⇒ { baa! baaa! baaaa! baaaaa! . . . }
State transition tables
I
Rows represent states
(i.e. q ∈ Q)
I
Columns represent
possible input from the
vocabulary Σ
I
I
Cells are transitions
given a state and input
(i.e. δ q, i )
Final states are denoted
using a colon
Input
State
b
0
1
2
3
4:
1
a
!
2
3
3
4
Recognising deterministic FSAs
D-Recognise
Input: input string, state-transition-table, final-states
Output: accept or reject
current-state ← 0;
index ← 0;
repeat
if end of input then
if current-state is in final-states then
return accept;
else
return reject;
end
else if state-transition-table[current-state, input[index]] is empty then
return reject;
else
current-state ← state-transition-table[current-state, input[index]];
index ← index + 1;
end
until stop;
Non-deterministic FSAs
/b((aa)+|(aaa)+)!/ ⇒ {
baa!
baaa!
baaaa!
baaaaaa!
...
}
Abstract approaches to searching
Heuristic
I
Look ahead at input beyond the current index
I
Try to work out/guess which branch to take
Parallel
I
Assume unlimited number of cpus etc.
I
Copy state and remaining input, search all branches
Backtracking
I
Keep track of choice points
I
Follow each branch, returning to choice points on failure
Recognising non-deterministic FSAs
ND-Recognise
Input: input string, state-transition-table, final-states
Output: accept or reject
agenda ← {h0, 0i};
repeat
current-state, index ← pop(agenda);
if end of input and current-state in final-states then
return accept;
end
for next-state in state-transition-table[current-state, input[index]] do
agenda ← agenda ∪ {hnext-state, index + 1i};
end
if agenda is empty then
return reject;
end
until stop;
-transitions
Arcs that do not consume input are called -transitions
-transitions: Concatenation
-transitions: Closure (*)
-transitions: Union (|)
Deterministic and non-deterministic FSAs
Are non-deterministic FSAs more powerful?
No, every non-deterministic FSA has a deterministic equivalent
(Hopcroft and Ullman, 1979).
But they are easier to read—given a non-deterministic FSA with
n nodes, its deterministic equivalent can have up to 2n nodes.
Hopcroft, J. E. and Ullman, J. D. (1979). Introduction to Automata Theory,
Languages and Computation. Addison-Wesley.
Finite state transducers (FST)
Finite state automata represent strings in language. Finite state
transducers are a type of FSA which map between string pairs.
They can have several functions:
Recognisers Given a pair of strings, determine whether they
are in the string pair language
Generators Represent how to construct output in the string
pair language
Translator Read in one string and output another string
Relator Compute relations between sets
Defining finite state transducers
Jurafsky & Martin 2009
Q = {q0 , q1 , . . . , qN−1 } a finite set of N states
Σ
a finite input vocabulary
∆
a finite output vocabulary
qo
the start state
F
the set of final states, F ⊆ Q
δ q, i σ q, i
the transition function
the output function giving the set
of possible output strings for each
state and input
Translating Sheeptalk
/baa+!/ becomes /bæ+!/
q0
a:æ
a:
b:b
q1
q2
!:!
q3
q4
a:æ
Exercise: Hunden snakke
Draw a transducer for Norwegian and English dogs, i.e.
/(vo(ff|v)[ $])+/ becomes /(woof[ $])+/
Controlling agent behaviour with FSAs
An FSA can control agents in games, e.g.
ghosts in Pac-Man have four behaviours:
1. Wander the maze
2. Chase Pac-Man
3. Run away from Pac-Man
4. Return to the centre
Each of these behaviours depend on
certain triggering events.
Ghost FSA
sight Pac-Man
q0
wander
maze
Pac-Man eats
power-up
is in
centre
q4
return
to centre
lose sight of Pac-Man
q1
chase
Pac-Man
Pac-Man eats
power-up
power-up
wears off
is eaten by Pac-Man
q2
run from
Pac-Man
Summary
I
Modeling sequences of words with finite state automata
(FSAs)
I
FSAs are models of computation that can be in a finite
number of states
I
We define transitions that change the state of the machine
I
Non-deterministic FSAs contain choice-points, where for
some combination of state and input there is more than
one possible action
I
These can be handled with a back-tracking search
I
Finite state transducers produce output in response to
input
Next week
I
Probability theory: terminology and notation
I
Estimating probability of words using corpora
I
Handling unseen sequences
I
Applications in natural language processing