Introduction to Computational Linguistics

17. Using Finite State Transducers 65
In the fourth step, we have no choice in the first line: we have consumed the input,
now we need to choose t(2). In the other cases we have both options still.
(171)
And so on.
Step 4
t(0), t(1), t(1), t(2) : 1, aaa| : bb|bb
t(0), t(1), t(2), t(1) : 1, aaa| : bb|bb
t(0), t(1), t(2), t(2) : 1, aaa| : bbb|b
t(0), t(2), t(1), t(1) : 1, aaa| : bbb|b
t(0), t(2), t(1), t(2) : 1, aa|a : bbb|b
t(0), t(2), t(2), t(1) : 1, aa|a : bbb|b
t(0), t(2), t(2), t(2) : 1, a|aa : bbbb|
It should be noted that remembering each and every run is actually excessive.
If two runs terminate in the same configuration (state plus pair of read strings),
they can be extended in the same way. Basically, the number of runs initially
shows exponential growth, while the number of configurations is quadratic in the
length of the smaller of the strings. So, removing this excess can be vital for
computational reaons. In Step 3 we had 4 runs and 3 different end situations, in
Step 4 we have 7 runs, but only 4 different end configurations.
Thus we can improve the algorithm once more as follows. We do not keep a
record of the run, only of its resulting configuration, which consists of the state
and positions at the input and the output string. In each step we just calculate the
possible next configurations for the situations that have recently been added. Each
step will advance the positions by at least one, so we are sure to make progress.
How long does this algorithm take to work? Let’s count. The configurations are
triples 〈x, j, k〉, where x is a state of the machine, i is the position of the character
to the right of the bar on the input string, k the position of the character to the right
of the bar on the output string. On 〈⃗x,⃗y〉 there are |Q| · |⃗x| · |⃗y| many such triples.
All the algorithm does is compute which ones are accessible from 〈0, 0, 0〉. At
the end, it looks whether there is one of the form 〈q, |⃗x |⃗y|〉, where q ∈ F (q is
accepting). Thus the algorithm takes |Q| · |⃗x| · |⃗y| time, time propotional in both
lengths. (Recall here the discussion of Section ??. What we are computing is the
reachability relation in the set of configuations. This can be done in linear time.)
One might be inclined to think that the first algorithm is faster because it goes
into the run very quickly. However, it is possible to show that if the input is