In many situations of communication a speaker need not to worry about the possible ambiguity of what she is saying because she can assume that the hearer will be able to disambiguate the utter­ance by means of contextual information or would otherwise ask for clarification. But in some sit­uations it is necessary to avoid the risk of gen­erating ambiguous utterances that could lead to misunderstanding by the hearer, e.g., during the process of writing text, where no interaction is possible, or when utterances refer to actions that have to be performed directly or in some specific dialog situations (e.g. having an interview with a company).

The need to generate un-ambiguous utterances is also relevant for the development of natural language generation systems. For example in the case of an intelligent help-system that sup­ports the use of an operating system (Wilensky el n/., 1984), asking an inexperienced user to 'Re­move the folder with the system tools' could have tremendous effects on the system itself.

If one assumes a modular division of the natu­ral language generation task between two stages

^Rijksuniversiteit Groningen Postbus 716 NL 9700 AS Groningen vannoord@let.rug.nl

of the language production process — deciding what to say (conceptual level) and deciding how to say it (grammatical level) — it is not realis­tic to expect that the conceptual component will be able to specify the input for the grammatical component such that ambiguous utterances can be avoided.

If it were possible to specify the input in such a way, then this would mean that the conceptual component has to provide all information needed by the grammatical component to make decisions about lexical and syntactic choices. Hence, the conceptual component would need detailed in­formation about the language to use. But this would blur the distinction between the grammat­ical and the conceptual level, because this would imply that both components share the grammar (see also Appelt (1989), Meteer (1990), Neumann (1991)).

In order to maintain a modular design addi­tional mechanisms are necessary to perform some monitoring of the generator's output. Several authors argue for such additional mechanisms (Jameson and Wahlster, 1982; De Smedt and Kempen, 1987; Joshi, 1987; Levelt, 1989). For example, Levelt (1989) pointed out that "speak­ers monitor what they are saying and how they are saying it". In particular he shows that a speaker is also able to note that what she is say­ing involves a potential ambiguity for the hearer and can handle this problem by means of self-monitoring.

In this paper we describe an approach for self-monitoring which allows to generate un­ambiguous utterances in such situations where possible misunderstandings by the user have to be avoided. The proposed method is based on a very strict integration of parsing and genera­tion. During self-monitoring a generated ambigu-

JAs pointed out in Fodor (1983) one of the character­istic properties of a module is that it is computationally autonomous. But a relevant consideration of computa­tionally autonomy is that modules do not share sources (in our case the grammar), aus utterance is parsed and the obtained alterna­tive derivation trees are used as a 'guide' for the 'monitored generation step. We will show that such an integrated approach makes only sense with reversible grammars. To our knowledge, there is at present no algorithm that solves the problem of generating un-ambiguous utterances by means of self-monitoring.

Our approach is based on a strict integration of parsing and generation in that parsing is used to detect whether a produced utterance is ambigu­ous or not. The advantages of using comprehen­sion mechanisms to facilitate monitoring arc for example mentioned in Levelt (1989). In his model parsing and generation are performed in an iso­lated way by means of two different grammars. The problem with this view is that generation of un-ambiguous paraphrases can be very inefficient, because the source of the ambiguous utterance is not used to guide the generation process.

To overcome this problem the basic idea of our approach is to operate with derivation tites ob­tained during the generation and parsing step. In short, the algorithm works as follows. Firstly, it is checked whether a produced utterance S of an input form LI' is ambiguous, by parsing S, If during parsing e.g. two readings LF and LF' are deduced LF is generated again along the parse trees obtained for S. Now an utterance S' can be generated that has the same meaning but differs with respect to the ambiguity source of S.

In this way the derivation trees obtained dur­ing parsing of a previously generated utterances are used as a guide during monitored generation. Grammatical structures obtained during parsing are used directly to restrict the search space dur­ing generation. At this point it should be clear that the only way in order to be able to generate 'along parsed structures' is to use reversible gram­mars. This ensures that every sentence produced by the generator can be parsed. Similarly, for ev­ery semantic structure computed by the parser, the generator delivers an utterance.

A naive strategy. The first and most straight­forward solution to obtain only un-ambiguous ut­terances during generation could be described as a 'brute force' solution. The generator de­rives possible utterances for a given logical form. For each of these utterances it is easy to check whether it is ambiguous or not, by counting the results the parser delivers for that utterance.

In a Prolog implementation this simple solution can be defined as follows. Note that we assume for simplicity that linguistic signs are represented with terms signfLF.Str^ynjDer) where LF represents the semantic information, Str repre­sents the string and Syn represents syntactic in­formation. The fourth argument position will be used later in this paper to represent derivation trees.

monitor(aign(LF,Str,Syn,Der)): generate(sign(LF,Str,Syn,Der)), unambiguous(Str).

unambiguous(Str) :-

setof CLF,D""S~parse(sign(LF,StrfS(D), CEI] ).

The predicates parse/1 and generate/i call re­spectively the underlying parser and generator. The setof predicate is used to obtain the set of solutions of the parse predicate, where " indi­cates that, D and S are existentially quantified. By instantiating the resulting set as a set with exactly one element, we implement the idea that the utterance should be un-ambiguous (in that case there is only one parse result). Given Pro­log's search strategy this definition implies that the generator generates solutions until an un­ambiguous utterance is generated.

The problem with this 'generate and test' ap­proach is that the search of the generator is not directed by the goal to produce an un-ambiguous result. We will now present a more involved mon­itoring strategy which is oriented towards the goal of producing an un-ambiguous utterance.

Ambiguities are often 'local'. A fundamen­tal assumption is that it is often possible to obtain an un-ambiguous utterance by slightly changing an ambiguous one. Thus, after generating an am­biguous utterance, it may be possible to change that .utterance locally, to obtain an un-ambiguous utterance with the same meaning. In the case of a simple lexical ambiguity this idea is easily il­lustrated. Given the two meanings of the word 'bank' ('river bank' vs. 'money institution') a generator may produce, as a first possibility, the following sentence in the case of the first reading of 'bank'.

Properties. Some of the important properties of our approach can be characterised as follows.

The strategy is sound and complete in the sense that no ambiguous utterances will be produced, and all un-ambiguous utterances are produced. If for a given semantic structure no un-ambiguous utterance is possible, the current strategy will not deliver a solution (it is foreseen that in such cases the planner decides what should happen).

The strategy is completely independent on the grammars that are being used (except for the re­liance' on derivation trees). Even more interest­ingly, the nature of the underlying parsing and generation strategy is not important either. The strategy can thus be used with any parsing- or generation strategy.

During the monitored generation previously generated structures are re-used, because only the ambiguous partial structures have to be re­generated,

Finally, for the proposed strategy to be mean­ingful, it must be the case that reversible gram­mars are being used. If this were not the case then it would not make sense to compare the deriva­tion tree of a generation result with the derivation trees which the parser produces.

Generation of Paraphrases. In Neumann and van Noord (to appear) we discuss the imple­mentation of a variant of the monitoring strategy, to solve the problem of the generation of para­phrases.

If parsing an utterance has lead to several read­ings, one way in order to determine the intended meaning is to start a clarification dialog, in which the multiple interpretations of the parsed utter­ance arc contrasted by restating them in different form. The dialog partner is then requested to choose the appropriate paraphrase, by asking her 'Do you mean X or Y ?'.

The advantage of our approach is, that it will be ensured that the source of the ambiguity is used directly during the production of such para­phrases. Therefore, the generation of irrelevant paraphrases is avoided.

Limitations. It should be clear that monitor­ing involves more than the avoidance of ambigu­ities. Levelt (1989) discusses also monitoring on the conceptual level and monitoring with respect to social standards, lexical errors, loudness, pre­cision and others. Obviously, our approach is re­stricted in the sense that no changes to the input LF are made.

Metcer (1990) makes a strict distinction be­tween processes that can change decisions that operate on intermediate levels of representation (optimisations) and others that operate on pro­duced text (revisions). Our strategy is an exam­ple of revision. Optimisations are useful when changes have to be done during the initial gen­eration process. For example, in Neumann and

Finkler (1990) an incremental and parallel gram­matical component is described that is able to handle under-specified input such that it detects and requests missing but necessary grammatical information.

Implementation. In Levelt (1989) and Meteer (1990) the need for revision respectively moni­toring is discussed in detail although they de­scribe no implementations. As far as we know our approach is the first implementation of re­vising a produced utterance in order to find an un-ambiguous alternative. The underlying parser and generator are described in Shieber et al. (1990) and van Noord (1991). We are using lex-icalized unification-based grammars for German and Dutch.

This research work has been partially supported by the German Science Foundation in its Special Collaborative Research Programme on Artificial Intelligence and Knowledge Based Systems (SFB 314, Project N3 BiLD), and by the DFKI in the project DISCO, funded by the German Ministry for Research and Technology under Grant-No.: ITW 9002.