Future work

It is important to investigate the implications contextual information has for disambiguation of single utterances. Clearly, in many situations of communication it is not necessary to avoid an ambiguous utterance because the context forces the intended meaning. What is really needed is a generalisation of our method which takes context into account, i.e. an contextually sensitive method. Furthermore, such a method may also be useful for single utterances to achieve a more efficient and realistic monitoring strategy, where generation and parsing are integrated in an incremental way.

The need for contextual sensitivity within single utterance

The basic strategy used for generating unambiguous utterances and paraphrases described so far can be denoted as a global method because it operates over fully determined derivation trees of sentences. A fundamental assumption is that it is often possible to change an ambiguous utterance locally to obtain an unambiguous utterance with the same meaning. If we were to base an incremental method on this local view, where during generation already produced partial strings are monitored before the whole string is produced then we would run into problems.

Such a strategy works for an example like:

Here, the relevant ambiguity of the whole utterance is forced by the partial string `Removing the folder with the system tools'. This ambiguity can be solved by restating the partial string, e.g., as `Removing the folder by means of the system tools' independently from the rest of the string.

However, consider the ambiguous string `visiting relatives' which can mean `relatives who are visiting someone' or `someone is visiting relatives'. If this string is part of the utterance

then a local disambiguation of `visiting relatives' is helpful in order to express the meaning of the whole utterance clearly. But if this string is part of the utterance

then it is not necessary to disambiguate `visiting relatives' because the specific form of the auxiliary forces the first reading `relatives who are visiting someone'.

This phenomena is not only restricted on the phrasal level but occurs also on lexical level. For example, `ball' has at least two meanings, namely `social assembly for dancing' and `sphere used in games'. If this word occurs in the utterance

then the preposition `during' forces the first meaning of `ball'. Therefore it is not necessary to disambiguate `ball' locally. But, for the utterance

`ball' cannot be disambiguated by means of grammatical relations of the utterance.

The problem is that one has to control the monitor already during incremental processing of single utterances in order to decide when disambiguation of ambiguous partial structures has to take place. Technically, it is possible to check and revise the partial results of each recursive call of the generator. But, without any control, the monitor would try to disambiguate each local ambiguity; it is hard to imagine that the resulting generator would produce anything at all.

Outline of an incremental method

An utterance can only be said to be (un)ambiguous with respect to a certain context. The assumption is that usually an utterance which is not ambiguous w.r.t. its context will remain unambiguous if it is part of a larger utterance.

Assume we have a predicate parse_wrt_context(Str,Sign,Cont), which parses a string Str as a sign Sign with respect to context Cont. The monitoring strategy can be revised in order to use this predicate instead of the parse predicate. Only those sources of ambiguities are taken into account that lead to relevant ambiguities w.r.t. the context.

More speculatively, it may be possible to restrict the context during the production of a partial utterance to grammatical properties, e.g. to the information associated with the head which selects the phrase dominating this partial utterance. Such an approach can be integrated in head-driven generators of the type described in [Shieber et al.1990].

For example, assume that for each recursive call to the generator the revised monitor is called, with an extra argument Head which represents the context for the parse_wrt_context predicate. Thus, suppose we are to generate from the logical form

during'(ball')

A head-driven generator first produces the word during as the head. Next a NP with logical form ball' has to be generated. For this logical form the generator chooses the word ball which is however ambiguous. For this partial utterance the monitor is called, using the head information of `during'. However, being an argument of the head `during', only one of the readings of `ball' is possible. Therefore, the monitor simply `confirms' the choice of the generator. Thus, the assumption here is that this ambiguity will be disambiguated later on by combining this string with its head. Clearly, this need not always be the case -- therefore this strategy can be seen as a preference over the search space for the generator, using a sort of structural `look-a-head'.