<?xml version="1.0" standalone="yes"?>
<Paper uid="C92-2105">
  <Title>Self-Monitoring with Reversible Grammars</Title>
  <Section position="3" start_page="0" end_page="0" type="metho">
    <SectionTitle>
2 Overview of the Monitor-
</SectionTitle>
    <Paragraph position="0"> ing Algorithm Our approach is based on a strict integration of parsing and generation in that parsing is used to detect whether a produced utterance is ambiguous or not. The advantages of using comprehension mechanisms to facilitate mointoriug arc for example mentioned in Levelt (1989). \[n his model parsing and generation are performed in an isolated way by means of two different granunars.</Paragraph>
    <Paragraph position="1"> 'Phe problem with this view is that generation of un-ambiguous paraphrases can be very inefficient, because the source of the ambignons utterance is not used to guide the generation process.</Paragraph>
    <Paragraph position="2"> To overcome this problem the basic idea of our approach is to operate with derivation tl~es obtained during the generation and parsing step.</Paragraph>
    <Paragraph position="3"> In short, the algorithm works as follows. Firstly, it is checked whether a produced utterance S of an input form LF 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.</Paragraph>
    <Paragraph position="4"> In this way the derivation trees obtained during parsing of a previously generated utterances are used as a guide during monitored generation.</Paragraph>
    <Paragraph position="5"> Grammatical structures obtained during parsing arc used directly to restrict the search space during generation. At this point it shouhl 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 every semantic structure computed by the parser, the generator delivers an utterance.</Paragraph>
  </Section>
  <Section position="4" start_page="0" end_page="0" type="metho">
    <SectionTitle>
3 A monitoring strategy
</SectionTitle>
    <Paragraph position="0"> A naive strategy. The tirst and most straight-forward solution to obtain Olfly nn-ambiguous utterances during generation could hc described as a 'brute force' solution. The generator derives possible utterances for a given logical form.</Paragraph>
    <Paragraph position="1"> 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.</Paragraph>
    <Paragraph position="2"> Ina Prolog implementation this simple solution can be detincd as follows. Note that we assume for simplicity ttlat linguistic signs are represented with terms sign(LF,Str,Syn,Der) where LF represents tile semantic information, Str represents the string and Syn represents syntactic information. The fourtil argument position will be used later in this paper to represent derivation trees.</Paragraph>
    <Paragraph position="3">  monitor(sign(LF,Str,Syn,Der)):geuerate(sign(LF,Str,Syn,Der)), null unambiguous(Sir).</Paragraph>
    <Paragraph position="5"> \[El\]).</Paragraph>
    <Paragraph position="6"> The predicates paxse/1 and generate/1 call respectively the underlying parser and generator. The seto~ predicate is used to obtain the set of solutions of the parse predicate, where &amp;quot; indicates 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 Prolog's search strategy this definition implies that the generator generates solutions until an un-ambiguous utterance is generated.</Paragraph>
    <Paragraph position="7"> The prol)lem with this 'generate and test' approach 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 monitoring strategy which is oriented towards tile goal of producing an un-ambiguous utterance.</Paragraph>
    <Paragraph position="8"> Ambiguities are often 'local'. A flmdameutal assumption is that it is often possible to obtain an un-ambiguous utterance by slightly changing an ambiguous one. 'fhus, after generating an ambiguous utterance, it may bc possible to change that utterance locally, to obtain an un-ambiguous utterance with the same meaning. In the ease of a simple lexieal ambiguity this idea is easily illustrated. 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 eo.se of the first reading of 'bauk'.</Paragraph>
    <Paragraph position="10"> (I) John was standing near the bank while Mary tried to make a picture of him.</Paragraph>
    <Paragraph position="11"> To 'repair' this utterance we simply alter the word 'bank' into the word 'river bank' and we obtain an un-ambiguous result. Similar examples can be constructed for structural ambiguities. Consider the German sentence: (2) Heute ist durch alas Au~nministerium bekanntgegeben women, daft Minister van den Broek den jugoslawischen Delegationsleiter aufgefordert hat, die Armee aus Kroatien zuriickzuziehen.</Paragraph>
    <Paragraph position="12"> Today it was announced by the ministry of foreign affairs that minister van den Brock has requested the Yugoslav delegation leaders to withdraw the army from Croatia, which is ambiguous (in German) between 'withdraw \[the army of Croatia\]' and '\[withdraw \[the army\] away from Croatia\]'. In German this ambiguity can be repaired locally simply by changing the order of 'aus Kroatien' and 'die Armee', which forces the second reading. Thus again we only need to change only a small part of the utterance in order for it to be un-ambiguous.</Paragraph>
    <Paragraph position="13"> Locating ambiguity with derivation trees.</Paragraph>
    <Paragraph position="14"> We hypothesise that a good way to eharacterise the location of the ambiguity of an utterance is by referring to the notion of'derlvation tree'. We are assuming that the underlying grammar formalism comes with a notion 'derivation tree' which represents how a certain derivation is licenced by the rules and lexical entries of the grammar. Note that such a derivation tree does not necessarily reflect how the parser or generator goes about finding such a derivation tree for a given string or logical form. For example, the derivation trees of the two readings of 'john is standing near the bank' may look as in figure 1. The intuition that the ambiguity of this sentence is local is reflected in these derivation trees: the trees are identical up to the difference between bamk4 and bank7.</Paragraph>
    <Paragraph position="15"> In our examples each sign sign(LF,Str,Syn,D) is specified for its corresponding derivation tree D. In Prolog such a tree is represented with terms of the form t;(Label,Ds,M) where Label is the node name (the unique name of a rule) and Ds is a list of Daughter trees. The third argument position will be explained below.</Paragraph>
    <Paragraph position="16"> Given a derivation tree t of a generated sentence s, we mark the places where the ambiguity occurs as follows. If s is ambiguous it can be parsed in several ways, giving rise to a set of derivation trees T = tl...tn. We now compare t with the set of trees T in a top-down fashion.</Paragraph>
    <Paragraph position="17"> If for a given node label in t there are several possible labels at the corresponding nodes in T then we have found an ambiguous spot, and the corresponding node in t is marked. Thus, in the previous example of structural ambiguity we may first generate sentence (2) above. After checking wbetfier this sentence is ambiguous we obtain, as a result, the marked derivation tree of that sentence. A marked node in such a tree relates to an ambiguity. The relevant part of the resulting derivation tree of the example above may be the tree in figure 2.</Paragraph>
    <Paragraph position="18"> Markhlg a derivation tree. The predicate mark(Tree,Set) marks the generated tree Tree given the trees Set found by the parser. Tile third argument M of tile terms t (Labsl,Ds,M) repre- null senting derivation trees indicates whether the current node is marked (in that case the value is y) or not (using the value n). Subtrees of marked nodes have no instantiated value for this variable.</Paragraph>
    <Paragraph position="19">  mark(t(L,Ds,n),Set):root_same(L,Set),!, null get_ds(Set,DsSet), mark ds(Ds,DsSet).</Paragraph>
    <Paragraph position="20"> mark(t(L,Ds,y)~Set).</Paragraph>
    <Paragraph position="21"> root_same(L, \[\] ).</Paragraph>
    <Paragraph position="22"> root_same(L, \[t(L .... ) IT\] ) :root_same (L,T).</Paragraph>
    <Paragraph position="23"> mark ds(\[\],\[\]).</Paragraph>
    <Paragraph position="25"> Changing the ambiguous parts. SummarisinK, the generator first generates a possible utterance. This utterance is then given as input to the monitor. The monitor calls the parser to find which parts of that utterance are ambiguous.</Paragraph>
    <Paragraph position="26"> These parts are marked in the derivation tree associated with the utterance. Finally the monitor tries to generate an utterance whictl uses alternative derivation trees for the marked, i.e. ambiguous, parts.</Paragraph>
    <Paragraph position="27"> Generating an utterance given a marked dcrivation tree proceeds as follows. The generator simply 'repeats' the previous generation in a top-down fashion, as long as it encounters unmarked nodes. This part of the generation algorithm thus simply copies previous results. If a marked node is encountered the embedded generation algorithm is called for this partial structure. The result should be a different derivation tree than the given one. Now clearly, this may or may not he possible depending on the grammar. The next paragraph discusses what happens if it is not possible. null The following definition ~sumes that grammar rules are represented simply as rule(Name, No'thor, Ds) where Name is the rule name, Mother is the mother sign and Ds is a list of daughter signs. The predicate mgen is used to generate an utterance, using a marked derivation tree as an extra guide.</Paragraph>
    <Paragraph position="29"> mgen ds (T, Tire ~).</Paragraph>
    <Paragraph position="30"> II.edefining locality. Often it will not be possible to generate an alternative expression by a local change as wc suggested. Wc propose that the monitor first tries to change things ~-q local mq possible. If all possibilities are tried, the notion 'locality' is redefined by going up one level. This process repeats itself until no more alternative solutions are possible. Thus, given a marked derivation tree the monitored generation first tries to find alternatives for the marked parts of the tree.</Paragraph>
    <Paragraph position="31"> \]f no further possibilities exist, all markers in the trees are inherited by their mother nodes. Again the monitored generation tries to find alternatives, after which the markers are pushed upwards yet another level, etc.</Paragraph>
    <Paragraph position="32"> The following definition of the predicate laawkA..g(Treo, Set, Guido) will (procedurally speaking) first construct the 'guide' Guide given a derivation tree Tree and a set of derivation trees Set; upon backtracldng it will push the markers in the tree one level upward at the time.</Paragraph>
    <Paragraph position="33">  TreeSet).</Paragraph>
    <Paragraph position="34"> Simple attac/nnent example. In order to clarify the monitoring strategy we will now consider how an attachment ambiguity may be avoided. The following German sentence constitutes a simplified example of the sort of attachment ambiguity shown in (2).</Paragraph>
    <Paragraph position="35"> (3) Die M~inner haben heute die Frau mit dem Fer nglas gesehen.</Paragraph>
    <Paragraph position="36"> The men have today the woman with the telescope seen.</Paragraph>
    <Paragraph position="37"> Today the men saw the woman with the telescope.</Paragraph>
    <Paragraph position="38"> 2 In the actual implementation the predicate ~ind_all _parse is complicated in order to remember which parses were already tried. If a parse has been tried before, then the predicate fails because then that reslflt is either already shown to be ambiguous, or otherwise the colTssponding solution he.s already been found. Suppose indeed that the generator, as a first possibility, constructs this sentence in order to realize the (simplified) semantic representation: heute(mit(f ernglas, sehen(pl(mann), frau) ) Let us assume that the corresponding derivation tree is the tree in figure 3. To find out whether  this sentence is ambiguous the parser is called. The parser will find two results, indicating that the sentence is ambiguous. For the alternative reading tile derivation tree shown in figure 4 is found.</Paragraph>
    <Paragraph position="39">  The derivation tree of the result of generation is then compared with the trees assigned to the alternative readings (in this ease only one), given rise to the marked derivation tree shown in figure 5.</Paragraph>
    <Paragraph position="40"> The monitored generation will then try to find alternative possibilities at these marked nodes, However, no such alternatives exist. Therefore, the markers are pushed up one level, obtaining the derivation tree given in figure 6.</Paragraph>
    <Paragraph position="41"> ACRES DE COLING-92. NANTES. 23-28 Aou'r 1992 7 0 4 PREC. OF COLING-92, NANTES, AUO. 23-28, 1992  At this point the monitored generator again tries to find alternatives for tile marked nodes, this time sueeessflflly yielding: (4) Die Mgnner haben mit dem Fernglass die Prau gesehen.</Paragraph>
    <Paragraph position="42"> At this point we may stop. However, note that if we ask for further possibilities we will eventually obtain all possible results. For example, if the markers are pushed to the root node of the derivation tree we will also obtain (5) Mit dcm Ferngtass haben (lie Mgnner (lie l'Y=au gesehen.</Paragraph>
  </Section>
class="xml-element"></Paper>