File Information
File: 05-lr/acl_arc_1_sum/cleansed_text/xml_by_section/metho/96/c96-2155_metho.xml
Size: 20,961 bytes
Last Modified: 2025-10-06 14:14:11
<?xml version="1.0" standalone="yes"?> <Paper uid="C96-2155"> <Title>Generation of Paraphrases from Ambiguous Logical Forms</Title> <Section position="3" start_page="919" end_page="919" type="metho"> <SectionTitle> 2 Kay's Chart Generation Algorithm </SectionTitle> <Paragraph position="0"> In his algorithm, Kay proposes to use two devices to establish which phrases interact and when phrases can be folded together under a disjunctive edge. One device involves indexing edges on semantic variables and another keeps track of which part of the semantics each derivation expresses. In the semantic representation used in the algorithm, each fact is a predicate specifying a relation between events and entities. The events and entities are represented as variables that appear in the predicates and connect the various facts together. For example, the logical form \[chase(e,d,c), dogs(d), young(d), cats(c), young(c)\] denotes a chasing event (e) in which young dogs (d) chase young cats (c). Given this semantics as its input, the generator creates nominal edges with indices d and c as a realization of \[dogs(d),young(d)\] and \[cats(c), young(c)\], respectively, and verbal edges with index e as a realization of \[chase(e,d,c)\]. The packed generation forest encoding the four different realizations of the semantics (obtained by freely choosing between two ways of expressing each of the arguments: &quot;young dogs&quot;/&quot;puppies&quot; and &quot;young cats&quot;/&quot;kittens&quot;) is given in figure 1.1 Concentrating on the first argument, the constituents which render facts about the &quot;dog&quot; (nodes 1 to 6) are indexed on variable d; nodes 3 and 5 are folded together under node 6 as they are syntactically and semantically equivalent. The semantic equivalence is established on the basis of the indexing variable and the coverage of facts from the logical form.</Paragraph> <Paragraph position="1"> In parsing, identifying the coverage of the input is straightforward since phrases consist of consecutive items and combine at common end-points; the coverage of each edge is uniquely defined by its string posilNote that the traditional representation of charts (as transition diagrams) is not suitable for generation charts, essentially because of the absence of fixed positions. In order to simplify the exposition, we choose to represent the packed generation forest as an AND-0R tree (in which OR-nodes represent equivalent alternations and AND-nodes represent combination of daughters into larger constituents; OR-nodes are distinguished by the little arcs between their branches). Note that a forest representing multiple paraphrases can be reentrant, as later examples will demonstrate.</Paragraph> <Paragraph position="2"> tions. In generation this is not available since the semantics is unordered and the formation of subsets is relatively free- different lexical entries may cover different parts of the input and different syntactic realizations may choose to pack different facts together.</Paragraph> <Paragraph position="3"> Another source of complication comes from the fact that the generation chart encodes multiple paraphrases and we need to guarantee that a piece of semantics will not be expressed more than once.</Paragraph> <Paragraph position="4"> The mechanism used for keeping track of the semantic coverage of each edge consists of a bit array that represents the set of semantic facts. Each slot in the array corresponds to one fact and indicates whether the fact is expressed by that edge. When edges combine to form a larger constituent, their arrays anion together and checked to verify that no fact is duplicated. null The new generation method we propose in this paper is different from Kay's mainly in the criteria for indexing phrases and the mechanism used for determining the semantic coverage. The next sections describe these differences and demonstrate how they can be deployed to enable generation from undisambiguated semantics.</Paragraph> </Section> <Section position="4" start_page="919" end_page="922" type="metho"> <SectionTitle> 3 Generation with Annotated Charts </SectionTitle> <Paragraph position="0"> We propose a coarser notion of equivalence in order to let more phrases to be folded together. We still use the semantic variables as indices but we do not let the bit arrays be part of the identification of edges. We compensate for this by using a more powerful (and admittedly more complicated) mechanism to relate each constituent to the subset of the semantics it realizes.</Paragraph> <Paragraph position="1"> The mechanism consists of an array of boolean conditions, each corresponding to one semantics fact. A condition identifies a certain partial path in the packed generation forest; when this path is selected, the corresponding semantic fact is expressed.</Paragraph> <Paragraph position="2"> In the simple cases, when a constituent expresses the same semantic facts in all of its realizations, the condition can indeed be thought of as binary: if a slot contains 1 the corresponding fact is expressed by the edge and conversely if it is 0. In more complicated cases, when an edge has different realizations that cover different parts of the semantics, the indications in the arrays are given as boolean expressions composed of propositional variables. Each disjunctive edge in the chart is annotated with a set of such variables, each of which mutually exclusively defines a particular alternative derivation of that edge. These propositional variables compose into larger boolean expressions that define derivations of larger structures. For a general explanation of the method for using boolean expressions to handle disjunctions, see Maxwell and Kaplan (1989).</Paragraph> <Paragraph position="3"> The next example shows a chart with semantic arrays and exemplifies how the conditions appearing in their slots control realizations of the input. Consider the following logical form: \[dog(d), plural(d), big(d), bark(e,d), loud(e)\[ and the chart (forest) that would be constructed from it by the generation algorithm: In this drawing, the branches of the OR-nodes are labeled with propositional variables and below each edge is the array that indicates its coverage. For instance, node 2, which expresses &quot;dogs,&quot; covers the first 2 facts, hence its array is \[11000\]; node 5 which expresses &quot;bark&quot; contributes the 4th fact \[bark(e,d)\] and accordingly, its array is \[00010\]. Nodes 4 and 11 are disjunctive with choices represented by the proposition variables Pl,2 and ql,2 respectively. The NP of edge 4 can be realized as &quot;dogs&quot; if P2 is chosen or as &quot;big dogs,&quot; if Pl is chosen. This is reflected in the third slot of the array. It indicates that the third semantic fact is expressible in condition Pl. Likewise, the top-most S (node 11) is disjunctive since there are two ways to form a sentence: either using the VP of node 6 or the one of node 8, which also expresses the fifth fact about the barking event being loud. This explains the reason that expression of the fact \[loud(e)\[ is conditioned on the choice q2 (the 5th slot of the array in node 11). The two conditions taken together mean that a complete expression of the semantic input is conditioned on both Pl and q2 being the choices in the relevant disjunctions. null This example begins to show how the various components of the representation control the generation process. Before we continue with examples of more complex boolean conditions, we explain how the boolean arrays are constructed and what exactly is their logical interpretation.</Paragraph> <Section position="1" start_page="920" end_page="921" type="sub_section"> <SectionTitle> 3.1 Construction of the Boolean Arrays </SectionTitle> <Paragraph position="0"> In addition to the syntactic composition, the boolean arrays of the daughter constituents union to form the semantic array of the resulting mother constituent.</Paragraph> <Paragraph position="1"> Usually one daughter will have an array like \[...~0...\], the other \[...013j...\] and their combination will yield \[...oql~ j...\]. However, if both daughters express a particular semantic item the boolean expressions of the corresponding slots need to be disjoined (from the point of view of the mother they are alternative renditions).</Paragraph> <Paragraph position="2"> However, to avoid expressing the same facts more than once, a further constraint is required to guarantee that only one of the disjuncts eventually get chosen.</Paragraph> <Paragraph position="3"> This constraint is the negation of the conjunction of the two conditions. So, if we combine \[...C/q0...\] with \[...\[3j~...\] the result is \[...(cql~j)~j...\] and the negative condition ~(~i&l\]j) is added as a filter to the mother node. Whenever this node is traversed, the constraint needs to be honored. Note that the negative constraints are not composed into the boolean expressions. For a more elaborate explanation of this device, see Shemtov (1996).</Paragraph> <Paragraph position="4"> The meaning of combined conditions is the following. A disjunction indicates that there are multiple but mutually exclusive ways of expressing a certain semantic fact. In the array \[...(oqll3j)...\] the fact corresponding to the given slot can be rendered either by choosing the ith branch of the oc disjunction or thejth branch of the I~ disjunction. A conjunction defines a part of a certain path in the forest. It means that at two (or more) different nodes, only certain combinations of branches can be selected. In the array \[...(~&l~j)...\] we get a situation where in one oR-node (the ct disjunction) we need to select the ith branch and in another (the \]3 disjunction) we need to choose the jth branch.</Paragraph> <Paragraph position="5"> Another issue that is solved through the logical interpretation of the conditions is determining that the whole input is consumed. In parsing this is straightforward: there has to be a top-node from string position 0 to string position n. In the generation scheme developed here, this is much more complicated. Facts can be expressed only under certain conditions and it needs to be verified that the conditions are honored in a mutually consistent way. To determine whether all the semantic facts are expressed, the boolean conditions from all the slots in the array of the top node are conjoined and the result is checked for satisfiability. If the result is not satisfiable (no consistent assignment of truth values) or if it is not consistent with the negative constraints, then there is no path in the derivation graph that corresponds to an expression of all the facts.</Paragraph> <Paragraph position="6"> Admittedly, computing a satisfiable assignment to the various propositional variables can be hard (exponential complexity in the general case), however certain computational properties which are likely to exist (independence between sets of variables) will tend to make the computation much more efficient.</Paragraph> </Section> <Section position="2" start_page="921" end_page="922" type="sub_section"> <SectionTitle> 3.2 Paraphrases </SectionTitle> <Paragraph position="0"> Just as a parsing chart excels in compact representation of multiple interpretation of a single string, the generation chart is designed to represent multiple (string) realizations of the semantic interpretation and compute them at a minimal cost. As the following example demonstrates, the explicit encoding of conditions in which each fact is expressed provides a powerful way of controlling the realizations of the various paraphrases. It also provides a way for verifying that they do not overlap and express certain facts superfluously. Let us assume that the verbs &quot;enter&quot; and &quot;rush&quot; both decompose as movement verbs. The former would be represented as \[move(e,agent), into(e,loc)\] and the latter as \[move(e,agent), quick(e)\]. Also let us assume that the meaning of a PP headed by &quot;into&quot; is \[into(e,loc)\] and that \[quick(e)\] is also the semantics of the adverb &quot;quickly.&quot; With that, consider the following logical form \[John(j), move(e,j), into(e,r), room(r), quick(e)\] and the packed generation forest representing its various derivations (figure 3). The interesting action is in the fifth slot. \[quick(e)\] can be expressed by satisfying the condition qt&Pl&r2 which means choosing the left</Paragraph> <Paragraph position="2"> moved rushed into the room Figure 3 branches in nodes 16 and 11 and the right branch at node 3. This path corresponds to the sentence &quot;John rushed into the room.&quot; Another expression can be obtained by choosing q2 at node 16; this leads to node 13 on whose right branch the adverb &quot;quickly&quot; expresses \[quick(e)\]. Now, this situation is interesting because this fact is already contained in one of the branches of node I l, as we have already seen. To avoid expressing it twice, a further negative constraint is placed on node 13 which requires pl&r2 to be false. The constraint excludes the path that leads to a selection of the verb &quot;rush&quot; but it allows a choice of P2, which means that &quot;enter&quot; can be used to yield &quot;John entered the room quickly.&quot; It also allows a choice of the verb &quot;move&quot; since pl&rl represents a valid path. This way the sentence &quot;John moved into the room quickly&quot; is realized.</Paragraph> <Paragraph position="3"> This example demonstrates how multiple paraphrases are constructed out of a variety of lexical entries and syntactic constructions and how a record is kept relating the different phrases to the subsets of the semantic facts that they express, it shows that the generation method is sensitive to the particular lexicalization patterns that languages use to encode divergent parts of the semantics.</Paragraph> </Section> </Section> <Section position="5" start_page="922" end_page="923" type="metho"> <SectionTitle> 4 Generation from Ambiguous Semantics </SectionTitle> <Paragraph position="0"> The logical encoding of the boolean conditions may seem complex and indeed simpler solutions have been proposed to encode the semantic coverage (in Kay's algorithm for instance). However, the aim of the generation method we advocate here goes beyond rendition of fully specified semantics.</Paragraph> <Paragraph position="1"> One translation situatiou that the annotated chart approach can address very simply has to do with optional and defeasible specifications. In many situations there may be certain specifications in the input (discourse consideration, indication of preferences, etc.) that may not be crucial to the adequacy of the resulting expressions. For instance, in translation one might prefer to maintain the source language subject as the target language subject but be willing to accept a translation which violates this if generation would otherwise fail. This can happen when the source expression is passive but the corresponding target language verb does not passivize. Similarly, certain psychological verbs come in pairs (&quot;fear/frighten&quot;, &quot;like/ please&quot; etc.) but not in all languages, therefore a specification to express a pro:titular argument as the discourse topic might lead to a failure. For example, translating &quot;John likes it&quot; into Spanish most naturally comes out as &quot;it pleases John.&quot; The idea is that in such cases the generator will attempt to find an expression that conveys (or honors) all the specifications, but if such an expression is not admitted by the grammm&quot; it would still produce a grammatical result covering the crucial parts of the input.</Paragraph> <Paragraph position="2"> A more interesting problem that a chart with boor can conditions can address is how to use ambiguous semantics as an input to the generation process. Given that exhaustive disambiguation is not always possible, the idea is that the choice among the source language analyses will be delayed and the whole set of semantic interpretations will comprise the input to the generation process. The motivation is to gain more information from the target language in order to improve the quality of the choice. The crucial advantage that the proposed generation method provides is that it enables considering all of the semantic interpretations &quot;at once,&quot; avoiding the massive duplicated effort that would result from enumerating the logical forms and considering each one of them individually.</Paragraph> <Paragraph position="3"> The next two simplified examples demonstrate how logical forms which contain disjunctions can be processed by the generator and how the rich logical annotations relate the various paraphrases to the alternations in the semantics. The first example demonstrates a disjunction resulting from a structural ambiguity. The expression &quot;hydraulic oil filter&quot; lends itself to two different bracketings, corresponding to &quot;filter for hydraulic oil&quot; and &quot;hydraulic filter for oil.&quot; These two interpretations are given in the following disjunctive logical form: \[filter(f), oil(o), {hydraulic(o) I hydraulic(f)}\] Figure 4 shows the packed generation forest that encodes the two (incidentally identical) strings that express this piece of semantics.</Paragraph> <Paragraph position="4"> The generation from a disjunctive input proceeds just as before, as if the disjunction is ignored and all the semantic facts are given equal status. Then, when the results of the generation are to be enmnerated, the logical structure of the input reappears and affects the interpretation of tile boolean array. In this example, we know that either tile third fact or the fourth l~lct (but not both) can be expressed. Accordingly, we allow either the third or the fourth boolean condition to be satisfied. If we choose to satisfy the former, we let Pl be true and ql be false. This forces a traversal of nodes 9 and 3 which amounts to generating from \[filter(f), oil(o), hydraulic(o)\]. If oil the other we choose to express the other interpretation, we reverse the conditions. This requires a selection of the left branch in node 10 (ql) which means that \[hydraulic(f)\] gets expressed in node 7. At node 4 we refrain from expressing \[hydranlic(o)\] since we set Pl (the condition in the third slot) to false. This way we reconstruct the logical structure of the disjunctive logical form and select one interpretation at a time from the set of possible paraphrases.</Paragraph> <Paragraph position="5"> The next example shows how an NP is generated from a specification that results from a lexical ambiguity. Let us consider the following logical form that could be produced from analyzing &quot;little dog&quot; in a lm~- null guage that interprets &quot;little&quot; as an ambiguous adjective denoting either smallness in size or youngness in age.</Paragraph> <Paragraph position="6"> \[dog(d), {small(d) I young(d) } We assume that this semantics licenses &quot;small dog,&quot; &quot;young dog&quot; and &quot;puppy&quot; (but not &quot;young puppy&quot; or &quot;small puppy&quot;). Figure 5 shows the generation forest that encodes these renditions of the input.</Paragraph> <Paragraph position="7"> small young dog puppy Figure 5 Node 3 merges two different adjectives which are indexed on the same variable but express two different facts; Node 6 merges two nominal phrases with compatible but not completely overlapping meanings.</Paragraph> <Paragraph position="8"> Now, if our goal is to enumerate the paraphrases corresponding to the first interpretation, we satisfy the condition in the second slot \[small(d)\] and dissatisfy the condition in the third slot \[young(d)\]. As a result, we select the left branches of nodes 8 and 3 so as to satisfy h&pl. Note that at node 6 we can only choose the left branch because otherwise the condition of the third slot would also be satisfied, contrary to the mutually exclusive nature of the semantic alternation. When the goal is to generate the second interpretation, we reverse the conditions and try to satisfy (rl&Pa)lq2. If rl and p2 are set to true we get &quot;young dog&quot; If q2 is selected we choose the right branches of nodes 8 and 6 and get &quot;puppy.&quot; These two examples demonstrate how we manipulate the boolean conditions of the semantic coverage arrays to allow generation from a disjunctive input and still gain the benefits of the chart generation algorithm.</Paragraph> </Section> class="xml-element"></Paper>