Integration of Parsing and Generation

A promising approach to overcome these problems is to integrate generation and parsing in a strict way. By this we mean:

• the use of resulting structures of one direction directly in the other direction,
• the use of one mode of operation (e.g., parsing) for monitoring the other mode (e.g., generation).

A main thesis of this paper is that the best way to achieve such integrated approach is to use the same grammar as the linguistic basis for both processes.

Monitoring

In order to maintain a modular design additional mechanisms are necessary to perform some monitoring of the generator's output. The need for such mechanisms during natural language generation has already been noted by several authors [De Smedt and Kempen1987,Joshi1987,Levelt1989]. For example, [Levelt1989] points out that ``speakers 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 saying involves a potential ambiguity for the hearer and can handle this problem by means of self-monitoring.

In Levelt's model parsing and generation are performed in an isolated way by means of two different grammars. In such flow of control the complete structure has to be generated again if ambiguities are detected (by parsing the utterance) that have to be avoided. The problem with this view is that generation of unambiguous utterances can be very inefficient, because the relevant sources of the ambiguous utterance are not used to guide the generation process.

The same can happen during the generation of paraphrases. If for example an intelligent help-system that supports a user by using an operation system (e.g. Unix, [Wilensky et al.1984]), receives as input the utterance `Remove the folder with the system tools' then the system is not able to perform the corresponding action directly because it is ambiguous. But the system could start a clarification dialog and ask the user `Do you mean ``Remove the folder by means of the system tools'' or ``Remove the folder that contains the system tools''?'. This situation is summarised in figure 1 (LF^' and LF^'' symbolise two readings of S).

Figure 1: Relationship between ambiguities and paraphrases

As long as parsing and generation are performed in an isolated way the generator is not able to consider the source of the ambiguity such that it is ensured that only relevant paraphrases will be produced. For example, the generator could produce a paraphrase like `Do you mean: ``Delete the folder with the system tools''' which does not help to clarify the situation.

Self-Monitoring and Reversible Grammars

In order to be able to take into account relevant sources of ambiguities the basic idea of the integrated approach introduced in this paper is to operate with derivation trees obtained during the generation and parsing step by means of the same grammar.

The basic step of the approach is as follows: The monitor compares in each step the resulting structures of the generation process with the corresponding structures from parsing maintained in the alternative derivation trees in a top-down way (We will now assume that two derivation trees P₁ and P₂ are obtained during parsing). Suppose that LF^' is specified as the input to the generator. In the case where the generator encounters alternative grammatical structures to be expanded, the monitor guides the generator by means of inspection of the corresponding derivation trees. In the case where actual considered parts p₁ and p₂ of P₁ and P₂ (e.g., same NPs) are equal, then the generator has to choose the same grammatical structure that was used to build p₁ and p₂ (or more efficiently the generator can use the partial structure directly as a kind of compiled knowledge). In the case where a partial structure of e.g., parse tree P₁ has no correspondence in P₂ a relevant ambiguity source is detected. In this case an alternative grammatical structure has to be chosen.

At this point it should be clear that the only way in order to be able to generate `along parsed structures' is to use a reversible grammar in both directions because grammatical structures obtained during parsing are used directly to guide the generation process.

In the next two sections we describe in detail how this mechanism is used during generation of unambiguous utterances and generation of paraphrases.