Introduction to Computational Linguistics

17. Using Finite State Transducers 66
appropriately chosen, it might take exponential time to reach an answer. So, on
certain examples this algorithm is excessively slow. (Nevertheless, sometimes it
might be much faster that the breadth first algorithm.)
Now we look ata different problem: given an input string, what are the possible
output strings? We have already seen that there can be infinitely many, so one
might need a regular expression to list them all. Let us not do that here. Let
us look instead into ways of finding at least one output string. First, an artificial
example. The automaton has the following transitions.
(172)
0 a:c −→ 1
1 a:c −→ 1
2 b:ε
−→ 3
0 a:d −→ 2
2 a:d −→ 2
0 is initial, and 1 and 3 are accepting. This machine has as input strings all strings
of the form a + b?. However, the relation it defines is this:
(173) {〈a n , c n 〉 : n > 0} ∪ {〈a n b, d〉 : n > 0}
The translation of each given string is unique; however, it depends on the last
character of the input! So, we cannot simply think of the machine as taking each
character from the input and immediately returning the corresponding output character.
We have to buffer the entire output until we are sure that the run we are
looking at will actually succeed.
Let us look at a real problem. Suppose we design a transducer for Arabic.
Let us say that the surface form katab should be translated into the deep form
ktb+3Pf, but the form baktib into ktb+1Pr. Given: input string baktib. Configuration
is now: 0, |baktib. No output yet. The first character is b. We face
two choices: consider it as part of a root (say, of a form badan to be translated
as bdn+3Pf), or to consider it is the first letter of the prefix ba. So far there is
nothing that we can do to eliminate either option, so we keep them both open. It
is only when we have reached the fourth letter, t, when the situation is clear: if
this was a 3rd perfect form, we should see a. Thus, the algorithm we propose
is this: try to find a run that matches the input string and then look at the output
string it defines. The algorithm to find a run for the input string can be done as
above, using depth first or breadth first search. Once again, this can be done in
quadratic time. (Basically, the possible runs can be compactly represented and
then converted into an output string.)