{ "paper_id": "W90-0107", "header": { "generated_with": "S2ORC 1.0.0", "date_generated": "2023-01-19T04:00:27.561128Z" }, "title": "Using Bidirectional Semantic Rules for Generation", "authors": [ { "first": "Jim", "middle": [], "last": "Barnett", "suffix": "", "affiliation": { "laboratory": "", "institution": "Mani Microelectronics and Computer Technology Corporation (MCC)", "location": { "addrLine": "3500 West Balcones Center Drive Austin", "postCode": "78759", "settlement": "Texas", "country": "U.S.A" } }, "email": "" } ], "year": "", "venue": null, "identifiers": {}, "abstract": "This paper describes the use of a system of semantic rules to generate noun compounds, vague or polysemous words, and cases of metonymy. The rules are bidirectional and are used by the understanding system to interpret the same constructions.", "pdf_parse": { "paper_id": "W90-0107", "_pdf_hash": "", "abstract": [ { "text": "This paper describes the use of a system of semantic rules to generate noun compounds, vague or polysemous words, and cases of metonymy. The rules are bidirectional and are used by the understanding system to interpret the same constructions.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Abstract", "sec_num": null } ], "body_text": [ { "text": "In generation systems that are paired with understanding systems, bidirectionality is desirable for reasons that are both theoretical (a single model of linguistic behaviour) and practical (shorter development time, greater consistency, etc.) 1. Recently, [Shieber et al. 89] and [Calder at al. 89] have presented generation algorithms that share both semantics and syntax with the understanding system. This paper presents an extension of these algorithms to deal with phenomena that have often been lumped together under 'pragmatics', namely noun compounding, metonymy (the use of a word to refer to a related concept), and vague or polysemous words like \"have.\"", "cite_spans": [ { "start": 256, "end": 275, "text": "[Shieber et al. 89]", "ref_id": null }, { "start": 280, "end": 298, "text": "[Calder at al. 89]", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": null }, { "text": "The difficulty with these constructions is that they are productive, and cannot be handled easily by simply listing meanings in a lexicon. Taking noun compounding as an example, we have \"corn oil\" and \"olive oil\" referring to oil made from corn or olives. We could add a lexical sense for \"corn\" meaning \"made from corn,\" but then we face an explosion in the size of the lexicon, and an inability to understand or generate novel compounds: if we acquire \"safflower\" as the name of a plant, we would like the system to be able to handle \"safflower oil\" immediately, but this won't be possible if we need a separate lexical sense to handle compounding. The system will be more robust (and the lexicon more compact) if we can derive the desired sense of \"safflower\" from the basic noun sense when we need it. We have therefore developed a system of bidirectional semantic rules to handle these phenomena at the appropriate level of generality.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": null }, { "text": "IF or more detailed arguments along these lines, see [Appelt 87] , [Shieber 88 ], [Jacobs 88a].", "cite_spans": [ { "start": 53, "end": 64, "text": "[Appelt 87]", "ref_id": null }, { "start": 67, "end": 78, "text": "[Shieber 88", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": null }, { "text": "We have implemented these rules in Common Lisp as part of the KBNL system [Barnett et M. 90] at MCC, but nothing depends on the idiosyncracies of our formalisms or implementation, so the technique is compatible with a wide variety of theories of the kinds of relations that are likely to occur in these constructions, as in, e.g., [Finin 80] for noun compounds and [Nunberg 78] for oblique reference.", "cite_spans": [ { "start": 331, "end": 341, "text": "[Finin 80]", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Introduction", "sec_num": null }, { "text": "The algorithms for recognition and generation use an agenda-based blackboard for communication and control [Cohen et al. 89] .", "cite_spans": [ { "start": 107, "end": 124, "text": "[Cohen et al. 89]", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "The Framework", "sec_num": null }, { "text": "Our syntax component uses an extension of Categorial Unification Grammar [Wittenburg 86 ] as the phrase-structure component of an LFG-style functional representation (f-struCture), and the semantic component maps from this representation to sets of assertions in the interface language of the CYC knowledge base [Lenat et al. 90] .", "cite_spans": [ { "start": 73, "end": 87, "text": "[Wittenburg 86", "ref_id": null }, { "start": 312, "end": 329, "text": "[Lenat et al. 90]", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "The Framework", "sec_num": null }, { "text": "Semantic rules map partial semantic interpretations onto other partial interpretations. They consist of a left-hand side and a right-hand side, each consisting of one or more templates, plus a mechanism for mapping an instantiation of either set of templates onto an instantiation of the other set. The intuitive semantics of these rules is that any interpretation that matches the left-hand side licenses a second interpretation matching the right-hand side. For example, we can use the name of an author to refer to his works (\"I read Shakespeare\"), and the corresponding semantic rule states that the existence of an NP denoting an artist licences the use of the same NP to refer to his works. The generation system applies the rules in a backward-chaining direction, while the understanding system runs them forward. A later section contains a fuller discussion of the implementation of the rules, while the next sections discuss their use at runtime.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "The Framework", "sec_num": null }, { "text": "The generator is divided into strategic and tactical components. The former takes a frame as input and creates a description of it based on a set of discriminative properties which are recorded in the KB and indicate which aspects of a frame are likely to be salient. If a comparison class is available, the resulting description uniquely identifies the frame with respect to that class, otherwise it contains default 'interesting' properties. Once it has generated this set of assertions, the strategic component calls the tactical component with a goal Semantics : Syntax, where Semantics consists of the assertions plus the distinguished variable that the utterance is 'about', and Syntax is an f-structure (which may specify no more than the category.)", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Generation", "sec_num": null }, { "text": "Given this input, the tactical component uses a variant of the semantic-head driven algorithms described by [Calder at al. 89] and [Shieber et al. 89 ] to generate a phrase whose syntax and semantics match the goal. Before examining this algorithm, we note that in categorial grammars, most of the syntactic information is contained in the lexical definitions of words. For example, the lexical entry for a transitive verb like \"read\" specifies that it takes an object NP to its right and then a subject NP to its left. Any such constituent that takes at least one argument is called a funclor, while a constituent with no arguments is called atomic. Functors and their arguments are combined by a small number of binary rules, and there is also a set of unary rules, which can change the category of a constituent (forming passive verbs out of actives, for example.)", "cite_spans": [ { "start": 108, "end": 126, "text": "[Calder at al. 89]", "ref_id": null }, { "start": 131, "end": 149, "text": "[Shieber et al. 89", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Generation", "sec_num": null }, { "text": "Next we define two relationships between constituents and goals: first, a constituent matches a goal if its semantics subsumes the goal's semantics and its syntactic category is the same as the goal's, with possible extra arguments. Thus the transitive verb \"eat\", with category S\\NP/NP, is a syntactic match for the goal category S because it will he an S once it gets its arguments. Second, a constituent satisfies a goal if it has identical semantics and its f-structure is a supergraph of the goal's f-structure. Given this syntactic framework, the algorithm works by peeling off lexical functors and recursing on their arguments until it bottoms out in an atomic constituent. Given a goal, the first step consists of lexical look-up to find an item that matches the goal. Once this item, called the semantic head, is found, the algorithm proceeds both top-down and bottom up. If the semantic head is a functor, it proceeds top-down trying to solve the sub-goal for its argument. Once this sub-goal is satisfied, the algorithm works bottom-up by applying unary grammar rules to to the argument constituent alone, or binary rules to combine it with the functor. When a complete constituent is found which satisfies the goal, we are done.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Generation", "sec_num": null }, { "text": "The algorithm described above assumes a fixed set of choices in the lexicon. It can generate metonymic expressions and noun compounds, but only at the cost of massive lexical ambiguity. We therefore extend it by considering the possibility of goal revision as an alternative to the lexical look-up step s. By running a semantic rule backward, we can map the current goal onto one or more new goals to which the algorithm recursively applies. Satisfying the new goals will generate an expression with the desired meaning and thus indirectly satisfy the original goal.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Extension: Goal Revision", "sec_num": null }, { "text": "Revision using noun compounding rules leads to a binary decomposition of the original goal, as shown in Figure 2 , while metonymy rules result in a unary decomposition, as shown in Figure 3 . From this perspective, we note that the lexical look-up of a functor can be viewed as a kind of guided binary decomposition (Figure 1 ), splitting the original goal into two sub-goals with the knowledge that one of them will be satisfied immediately.", "cite_spans": [], "ref_spans": [ { "start": 104, "end": 112, "text": "Figure 2", "ref_id": "FIGREF3" }, { "start": 181, "end": 189, "text": "Figure 3", "ref_id": null }, { "start": 316, "end": 325, "text": "(Figure 1", "ref_id": "FIGREF0" } ], "eq_spans": [], "section": "Extension: Goal Revision", "sec_num": null }, { "text": "[ :o.L I (X HRSCOLOR Y) [ (x Isg BOOK) I (Y EOURLS RED) | (X HRSCRER/OR Z) I (Z EOURLS MRO) ]", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Extension: Goal Revision", "sec_num": null }, { "text": ".t. [Shieber et al. 89 ] thus amounts to the decision to allow top-down decomposition to be guided by rules as well as lexical items. As we would expect, this is the mirror image of the situation during understanding, where semantic rules are used as an extension to the lexicon in the process of merging translations bottomup. The extended algorithm is shown in the Appendix.", "cite_spans": [ { "start": 4, "end": 22, "text": "[Shieber et al. 89", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Extension: Goal Revision", "sec_num": null }, { "text": "I (U HRSCOLOR V)l |(X ISR BOOK) | [(X HRSCRERTOR Z)[ l(V E%URLS RED)] [(Z EOURLS .BO) I", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Extension: Goal Revision", "sec_num": null }, { "text": "The strategic component can control the choice among alternatives through its specification of the goal's syntax. For example, the strategic component can force the use of a compound by providing an appropriately detailed f-structure (i.e., one that specifies the presence of a modifier of category N.) If it does so, no matter whether we are in best-first or all-paths mode, only the compounding alternative will succeed and satisfy the syntactic goal. On the other hand, if the syntactic goal is underspecified, the output (in best-first mode) will aThe notion of goal revision in generation dates back to [Appelt 83] where various conditions could lead to replanning of the input; for recent work incorporating goal revision see [Vaughan et al. 86] .", "cite_spans": [ { "start": 608, "end": 619, "text": "[Appelt 83]", "ref_id": null }, { "start": 732, "end": 751, "text": "[Vaughan et al. 86]", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Controlling Rule Application", "sec_num": null }, { "text": "depend on the tactical component's heuristic ordering. In this case, given the default ordering which prefers lexical look-up to noun compounding to metonymy, the tactical component will use a noun compound when lexical look-up fails (i.e., there is no corresponding adjective or preposition). Another result of this default ordering is that metonymy will never fire in the absence of a syntactic specification since there is always another way (unless the lexicon is incomplete) of saying the same thing using words that are in the lexicon. However, the literal alternative is usually more verbose than the metonymous expression, ,so the strategic component can force the use of metonymy by specifying a limit on the number of words the tactical component is allowed to use. Given a limit of 3 words, descriptive phrases like \"a book by Joyce\" will fail, and only the metonymous expression \"Joyce\" will succeed.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Controlling Rule Application", "sec_num": null }, { "text": "In best-first mode, substantial improvements in efficiency are possible by re-ordering the alternatives based on the syntactic properties of the goal. For example, it makes sense to try metonymy first if the desired length is significantly less than the number of assertions in the goal's semantics, since each lexical item normally covers only a few assertions.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Controlling Rule Application", "sec_num": null }, { "text": "Suppose we have a Software-Machine rule, stating that if \"y\" denotes any kind of Software and \"x\" a computer, \"a y x\" means a Computer x that CanRun-Language y. Now consider a goal with semantics (W ISA Computer)(Z Equals Lisp)(W CanRunLanguage Z), distinguished variable W, and syntax NP. There is no lexical item covering all these assertions, or any lexical functor covering part of them (i.e., \"Lisp\" is not in the lexicon as an adjective.) Thus, even in best-first mode, we will end up applying the Software-Machine rule to this goal, resulting in the decomposition shown in Figure 2 . isfy the other. Combining the sub-goal solutions yields \"Lisp machine\" as a solution to the original goal.", "cite_spans": [], "ref_spans": [ { "start": 580, "end": 588, "text": "Figure 2", "ref_id": "FIGREF3" } ], "eq_spans": [], "section": "Generating Noun Compounds", "sec_num": null }, { "text": "Multiple compounds are handled by repeated invocations of the rules. Suppose we have a Mechanism-Maintenance rule, stating that if \"x\" denotes a Machine and \"y\" denotes any kind of MaintenanceOperalion, \"x y\" denotes a MaintenanceOperation y with y Maintains x. Given input semantics (Y ISA Repair-Operation)(Y Maintains X)(X ISA Computer)(X Can-RunLanguage Z)(Z Equals Lisp), with distinguished referent Y, the maintenance rule will eventually fire, generating patterns for a head (Y ISA RepairOperation) and a modifier (X ISA Computer)(X CanRunLanguage Z)(Z Equals Lisp). The head's goal will be satisfied by the entry for \"repair\", but processing of the modifier will invoke the Software-Machine rule, just as in the example above. The output will be \"Lisp machine repair\", with the left-branching structure [[Lisp machine] repair].", "cite_spans": [ { "start": 811, "end": 826, "text": "[[Lisp machine]", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Generating Noun Compounds", "sec_num": null }, { "text": "For an example of a right-branching compound, suppose we have a Product-Manufacturer rule stating that if \"x\" is the name of a Product and \"y\" is the name of a Company, then \"a y x\" is a Product x that is ManuffacluredBy company y. Given the input (X ISA Computer)(X UanufacturedBy Y)(X CanRunianguage Z)(Y Equals Symbolics)(Z Equals Lisp), the product rule will fire, producing a modifier sub-goal for (Y Equals Symbolics) and a head sub-goal for (X ISA Computer)(X CanRunLanguage Z) (Z Equals Lisp) . This time the Software-Machlne rule will be invoked on the head sub-goal, while lexical item \"Symbolics\" will satisfy the modifier sub-goal, and the output will be Recursing on the sub-goals, the lexical item \"Lisp\" will satisfy the left sub-goal, and \"machine\" will sat-Suppose we have an Artist rule licensing the use of an artist's name to refer to his works, and are trying to generate an NP with semantics (X ISA Book)(X HasCrealor JamesJoyce). If we are in all-paths mode, or if the strategic component has requested a succinct rule, we need to compute the inverse of the relation. 4 To do this we reverse the order of the statements and replace each Bind statement (which computes a relation between variable bindings) with its inverse. Here we rely on the fact that the CYC KB automatically maintains inverses for all relations defined in it (for KBs without this feature, we would have to define inverses for all relations used in rules). If CreatorOffis the inverse of HasGreator, then the inverse of (Bind Z (X CreatorOf)) is simply (Bind X (Z HasCreator)).", "cite_spans": [ { "start": 485, "end": 500, "text": "(Z Equals Lisp)", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Generating Noun Compounds", "sec_num": null }, { "text": "A few more details are necessary to complete the implementation. First, we define tlie relation Instances, which maps from classes to their elements, as the inverse of ISA. Next we define a concatenation operator + on relations, so that (Z (Instances + ttasGreator)) returns all the creators of instances of the class Z. 5 Next, we stipulate that if the variable X is already bound, (Bind X (Z ttasCreator)) acts as a Filter, returning T iff X is among the values for (Z gasCreator.) Finally, for reasons of efficiency, we cache separate patterns for backward and forward application, instead of reversing the expressions at run time. The generation and understanding patterns for the Artist rule are given below: (new-var HasCreator Y) Running the rule backward on (Q ISA Book)(Q HasCreator JamesJoyce), initial unification binds Q to W, Z to Book and Y to JamesJoyce. The Bind expression serves as a filter in this case, checking that Y is in fact the CrealorOfsome instance of Z, the Filter expression checks that Y is a Person, and the output is (X Equals JamesJoyce), which will match the lexical semantics for \"Joyce\" permitting us to use that NP to refer to the book. Running the rule forward on (X Equals JamesJoyce), Yis bound to JamesJoyce, the Filter expression again checks that Yis a Person, and the Bind expression binds Z to all the classes of objects Yis the CreatorOf(in this case, the class Book). The output is an expression denoting any Book which HasCreator JamesJoyce, thus letting us understand \"Joyce\" as referring to a Book.", "cite_spans": [ { "start": 714, "end": 736, "text": "(new-var HasCreator Y)", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Generating Noun Compounds", "sec_num": null }, { "text": "Input Pattern (W ISA Z)(new-var HasCreator X) Bind Y (Z Instances 4-HasCreator) Filter (Y ISA Person) OutputPattera (X Equals Y) Input Pattern (X Equals Y) Filter (Y ISA Person) Bind Z (Y CreatorOf + ISA) Output Pattern(W ISA Z)", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Generating Noun Compounds", "sec_num": null }, { "text": "The rule format is similar for noun compounds, except that there are two input patterns (in the forward direction) and a single output pattern. During understanding, the two patterns are unified with the inter-4Mathematically, a relation is a set of ordered pairs, and its inverse is the set of inverted pairs. Any relation is therefore guaranteed to have a unique inverse.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Generating Noun Compounds", "sec_num": null }, { "text": "5The inverse of (rl + r2) is ((inverse r2) + (inverse rl)).", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Generating Noun Compounds", "sec_num": null }, { "text": "pretations of the head and modifier nouns, the Filters and Binds work as before, and the output pattern is the interpretation of the compound. Backward application is as before, except that the output is a pair of instantiated patterns which the generation routine then uses as new goals. , rather than rules of the sort we propose. Other generation systems apparently construct noun compounds via specialized (uni-directional) strategies specified in the interface to the tactical component [McDonald et at. 88] , or a combination of these techniques [McKeown 82] . We have been unable to find discussions of generation of metonymy, though at least some cases of it could obviously be handled via lexical ambiguity.", "cite_spans": [ { "start": 492, "end": 512, "text": "[McDonald et at. 88]", "ref_id": null }, { "start": 552, "end": 564, "text": "[McKeown 82]", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Generating Noun Compounds", "sec_num": null }, { "text": "The use of semantic rules seems to us to handle most of the technical problems in providing an economical, bidirectional treatment of a variety of non-literal and/or vague constructions. At the heart of any reversible system is the notion of being able to run mappings forwards or backwards, so that, for example, the understanding and generation lexicons are inverses of each other. These rules are a natural extension of this mechanism to more complex constructions. Furthermore, these rules can handle a wide variety of phenomena. In addition to the examples discussed above, we have used semantic rules for the lexical semantics of vague words like \"have\" and \"of\", which are like noun compounding and metonymy in that the only alternative to massive lexical ambiguity is to compute the nature of the relation based on the interpretation of the arguments. This use of semantic rules for lexical semantics amounts to permitting a lexical item to further decompose its subgoal, instead of satisfying it immediately in the manner of Figure 1 . Finally, these rules do not commit us to any particular analysis of the constructions in question (except insofar as they assume separate levels of syntactic and semantic representation.) To take noun compounding as an example, we can implement a wide variety of theories of the kinds of relations compounds express and of the hierarchies among them.", "cite_spans": [], "ref_spans": [ { "start": 1034, "end": 1042, "text": "Figure 1", "ref_id": "FIGREF0" } ], "eq_spans": [], "section": "Discussion", "sec_num": null }, { "text": "The main open issue is the development of strategies for the use of these expressions. The problem is most acute in the case of metonymy. At present, the strategic component can force the use of metonymous expressions by requiring brevity. However, use of metonymy is not just a matter of succinctness since it also tends to indicate informality and familiarity. In more extreme uses, it may have a poetic or humorous force. To use metonymy, compounds, or other vague expressions successfully, we need a theory of how they effect the discourse, as well as a strategic component which is sophisticated enough to exploit the theory. As a first step in this direction, we are implementing a discourse module which will allow us to address some of these issues. For example, metonymous expressions are safer when used to refer to classes of objects that have already been described than when used to introduce new ones. If \"an Orris fishing rod\" has already been mentioned, then \"an Orris\" is likely to make sense, even to people who wouldn't have understood it the first time around. However, such individual heuristics will be of limited usefulness until they are integrated into a comprehensive model of communication.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Discussion", "sec_num": null } ], "back_matter": [ { "text": "We are grateful to Elaine Rich for comments on an earlier draft of this paper.", "cite_spans": [], "ref_spans": [], "eq_spans": [], "section": "Acknowledgments", "sec_num": null }, { "text": "Generation AlgorithmThe psuedocode for the generation algorithm is shown below, identifying the point of departure from the [Calder at al. 89] algorithm. The lexical lookup-step of line 1 is replaced with the more general top-down step of line la, by calling the new function ge,erafe-tp-dn.The rest of the (pseudo)code remains unchanged.Here are the language constructs used in the pseudocode. We denote local variable assignment as X := Y, with scope extending to the immediate containing construct. Destructuring by pattern matching is allowed, e.g. < X1 X2 X3 >:= Y simultaneously binds X1, X2 and X3 to the corresponding components in Y. AND and OR have exactly the behavior of Common Lisp AND and OR.For the sake of conciseness,the function choose is used as a shorthand for control strategies: in all-paths mode, it finds all solutions; in best-first mode it imposes a heuristic ordering on the choices and finds a single solution, finding any subsequent solutions on backtracking. The function choose-tp-dn-operatio, heuristically picks the best operation based on the goal. The functions match and satisfy are as defined earlier. The functions apply-unavy-bup-rule and apply-bi.avy-buprule constitute the rule application interface to grammar rules; similarly, the functions apply-uuary-tp-dnrule and apply-binary-tp-d.-rule constitute the rule application interface for the semantic rules.FUNCTION generate(Goal); 1AND(;;OLD: Subgoal :ffi lex-decomp (Goal) ;; NEW: la Subgoal := choose(generate-tp-dn(Goal)) ;; AS BEFORE: 2 choose(generate-bup(Subgoal, Goal))).FUNCTION generate-tp-dn(Goal); operation := choose(choose-tp-dn-operation(Goal)) CASE operation :lex lex-decomp(Goal) :unary-decomp ;; e.g. METONYMY RULES:choose(apply-unary-tp-dn-rule(Goal)) :binary-decomp ;; e.g. COMPOL~DING/VAGUEWORD RULES:AND( := choose(apply-binary-tp-dn-rule (Goal)), choose(generate(left-subgoal)), choose(generate(right-subgoal)), choose(apply-binary-bup-rule (left-subgoal, right-subgoal))).FUNCTION generate-bup(Subgoal, Goal); OR(satisfies(Subgoal, Goal), AND(Arg := choose(extract-arg(Subgoal)), Goall := choose(apply-binary-bup-rule (Subgoal, ARE)), choose(generate(Arg)), choose(generate-bup (Goall, Goal))), AND(Goall := choose(apply-unary-bup-rule (Subgoal)), choose(generate-bup (Goall, Goal)))).FUNCTION lex-decomp(Goal); AND(Subgoal := choose(lexical-lookup(Goal)), matches(Subgoal, Goal), Subgoal).", "cite_spans": [ { "start": 124, "end": 142, "text": "[Calder at al. 89]", "ref_id": null }, { "start": 1460, "end": 1466, "text": "(Goal)", "ref_id": null } ], "ref_spans": [], "eq_spans": [], "section": "Appendix:", "sec_num": null } ], "bib_entries": { "BIBREF0": { "ref_id": "b0", "title": "Telegram: A Grammar Formalism For Language Planning", "authors": [ { "first": "D", "middle": [ "E" ], "last": "Appelt", "suffix": "" } ], "year": 1983, "venue": "Proceedings of the ACt, M.I.T", "volume": "83", "issue": "", "pages": "15--17", "other_ids": {}, "num": null, "urls": [], "raw_text": "Appelt 83] D. E. Appelt, \"Telegram: A Grammar For- malism For Language Planning\", Proceedings of the ACt, M.I.T., 15-17 June, 1983.", "links": null }, "BIBREF1": { "ref_id": "b1", "title": "Bidirectional Grammars and the Design of Natural Language Generation Systems", "authors": [ { "first": "D", "middle": [ "E" ], "last": "Appelt", "suffix": "" }, { "first": ";", "middle": [ "J" ], "last": "Barnett", "suffix": "" }, { "first": "K", "middle": [], "last": "Knight", "suffix": "" }, { "first": "I", "middle": [], "last": "Mani", "suffix": "" }, { "first": "E", "middle": [], "last": "Rich", "suffix": "" }, { "first": "; J", "middle": [], "last": "Calder", "suffix": "" }, { "first": "M", "middle": [], "last": "Reape", "suffix": "" }, { "first": "H", "middle": [ "M" ], "last": "Zeevat ; R", "suffix": "" }, { "first": "T", "middle": [ "P" ], "last": "Cohen", "suffix": "" }, { "first": "E", "middle": [], "last": "Mccandless", "suffix": "" }, { "first": "", "middle": [], "last": "Rich", "suffix": "" } ], "year": 1987, "venue": "Proceedings of the 4th Conference of the European Chapter of the ACL", "volume": "", "issue": "", "pages": "233--240", "other_ids": {}, "num": null, "urls": [], "raw_text": "D. E. Appelt, \"Bidirectional Grammars and the Design of Natural Language Generation Systems\", TINLAP-3 Posilion Papers, New Mex- ico State University, 7-9 January, 1987. [Barnett et al. 90] J. Barnett, K. Knight, I. Mani, and E. Rich, \"Knowledge and Natural Language Pro- eessing', to appear in Communications of the ACM, August, 1990. [Calder at al. 89] J. Calder, M. Reape, and H. Zeevat, \"An Algorithm for Generation in Unification Cat- egorial Grammar\", Proceedings of the 4th Confer- ence of the European Chapter of the ACL, pp. 233-- 240, Manchester, 10-12 April, 1989. [Cohen et al. 89] R. M. Cohen, T. P. McCandless, and E. Rich, \"A Problem Solving Approach to Human- Computer Interface Management\", MCC Tech Report ACT-HI-g06-89, Fall 1989.", "links": null }, "BIBREF2": { "ref_id": "b2", "title": "The Semantic Interpretation of Compound Nominals", "authors": [], "year": 1980, "venue": "Team: An Experiment in the Design of Transportable Natural-Language Interfaces", "volume": "87", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "et al. 87] D. Dahl, M. Palmer, and R. Passon- neau, \"Nominalizations in Pundit\", Proceedings of the ACL, Stanford, 6-9 July, 1987. [Finin 80] T. Finin, \"The Semantic Interpretation of Compound Nominals\", University of Illinois, Ph.D. Dissertation, 1980. [Grosz et al. 85] B. Grosz, D. Appelt, P. Martin, and F. C. N. Pereira, \"Team: An Experiment in the Design of Transportable Natural-Language Inter- faces\", Artificial Intelligence.", "links": null }, "BIBREF3": { "ref_id": "b3", "title": "Generating Language with a Phrasal Lexicon", "authors": [ { "first": "", "middle": [], "last": "Hobbs", "suffix": "" } ], "year": 1988, "venue": "Proceedings of the ACL", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Hobbs et al. 88] J. K. Hobbs, M. Stickel, P. Martin, and D. Edwards, \"Interpretation as Abduction\", Proceedings of the ACL, Buffalo, 7-10 June, 1988. [IIovy 88] E. H. Hovy, \"Generating Language with a Phrasal Lexicon\", in D. D. McDonald and L.", "links": null }, "BIBREF4": { "ref_id": "b4", "title": "Natural Language Generation Systems", "authors": [ { "first": "", "middle": [], "last": "Bole", "suffix": "" } ], "year": 1988, "venue": "", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Bole, eds., Natural Language Generation Systems, Springer-Verlag, 1988.", "links": null }, "BIBREF5": { "ref_id": "b5", "title": "Achieving Bidirectionality", "authors": [ { "first": "]", "middle": [ "P S" ], "last": "Jacobs 88a", "suffix": "" }, { "first": "", "middle": [], "last": "Jacobs", "suffix": "" } ], "year": 1988, "venue": "Proceedings of the lth International Conference on Computational Linguistics", "volume": "", "issue": "", "pages": "267--269", "other_ids": {}, "num": null, "urls": [], "raw_text": "Jacobs 88a] P. S. Jacobs, \"Achieving Bidirectional- ity\", Proceedings of the lth International Confer- ence on Computational Linguistics, Budapest, 22- 27 August, 1988, pp. 267-269.", "links": null }, "BIBREF6": { "ref_id": "b6", "title": "Building Large Knowledge Based Systems, Representations and Inference in the CYC Project", "authors": [ { "first": "]", "middle": [ "P S" ], "last": "Jacobs 88b", "suffix": "" }, { "first": "; D", "middle": [], "last": "Jacobs", "suffix": "" }, { "first": "R", "middle": [], "last": "Lenat", "suffix": "" }, { "first": "", "middle": [ "D" ], "last": "Guha ; D", "suffix": "" }, { "first": "M", "middle": [ "W" ], "last": "Mcdonald", "suffix": "" }, { "first": "", "middle": [], "last": "Meteer", "suffix": "" } ], "year": 1988, "venue": "Second Conference on Applied Natural Language Processing", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Jacobs 88b] P. S. Jacobs, \"PHRED: A Generator for Natural Language Interfaces\", in D. D. McDonald and L. Bole, eds., Natural Language Generation Systems, Springer-Verlag, 1988. [Lenat et al. 90] D. Lenat and R. Guha, f'Building Large Knowledge Based Systems, Representations and Inference in the CYC Project\", Addison Wes- ley, 1990. [McDonald et al. 88] D. D. McDonald and M. W. Meteer, \"From Water to Wine: Generating Natu- ral Language Text from Today's Application Pro- grams\", Second Conference on Applied Natural Language Processing, Austin, 9-12 February, 1988.", "links": null }, "BIBREF7": { "ref_id": "b7", "title": "Lexical Selection in the Process of Language Generation", "authors": [ { "first": "K", "middle": [ "R" ], "last": "Mckeown", "suffix": "" }, { "first": ";", "middle": [ "S" ], "last": "Nirenburg", "suffix": "" }, { "first": "R", "middle": [], "last": "Mecardell", "suffix": "" }, { "first": "E", "middle": [], "last": "Nyberg", "suffix": "" }, { "first": "P", "middle": [], "last": "Werner", "suffix": "" }, { "first": "S", "middle": [], "last": "Huffman", "suffix": "" }, { "first": "E", "middle": [], "last": "Kenschaft", "suffix": "" }, { "first": "I", "middle": [], "last": "Nirenburg", "suffix": "" }, { "first": "; G", "middle": [], "last": "Nunberg", "suffix": "" } ], "year": 1978, "venue": "Generating Natural Language Text in Response to Questions About Database Structure", "volume": "87", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "K. R. McKeown, \"Generating Natural Language Text in Response to Questions About Database Structure\", University of Pennsylvania, Ph.D. Dissertation, 1982. [Nirenburg et al. 88] S. Nirenburg, R. MeCardell, E. Nyberg, P. Werner, S. Huffman, E. Kenschaft and I. Nirenburg, \"DIOGENES-88\", CMU Tech Re- port CMU-CMT-88-107, June 1988. [Nunberg 78] G. Nunberg, \"The Pragmatics of Refer- ence\", City College of New York, Ph.D. Disserta- tion, 1978. [Pustejovsky et al. 87] J. Pustejovsky and S. Niren- burg, \"Lexical Selection in the Process of Lan- guage Generation\", Proceedings of the A CL, Stan- ford, 6-9 July, 1987.", "links": null }, "BIBREF8": { "ref_id": "b8", "title": "A Uniform Architecture for Parsing and Generation", "authors": [ { "first": "S", "middle": [ "M" ], "last": "Shieber", "suffix": "" } ], "year": 1988, "venue": "Proceedings of the 121h International Conference on Computational Linguistics", "volume": "", "issue": "", "pages": "614--619", "other_ids": {}, "num": null, "urls": [], "raw_text": "Shieber 88] S. M. Shieber, \"A Uniform Architecture for Parsing and Generation\", Proceedings of the 121h International Conference on Computational Linguistics, Budapest, 22-27 August, 1988, pp. 614-619.", "links": null }, "BIBREF9": { "ref_id": "b9", "title": "A Semantic-fiend-Driven Generation Algorithm for Unification-Based Formalisms", "authors": [ { "first": "S", "middle": [ "M" ], "last": "Shieber", "suffix": "" }, { "first": "G", "middle": [], "last": "Van Noord", "suffix": "" }, { "first": "R", "middle": [ "C" ], "last": "Moore", "suffix": "" }, { "first": "F", "middle": [ "C N" ], "last": "Pereira", "suffix": "" }, { "first": "; D", "middle": [], "last": "Stallard", "suffix": "" } ], "year": 1986, "venue": "Proceedings of the AGL", "volume": "", "issue": "", "pages": "10--13", "other_ids": {}, "num": null, "urls": [], "raw_text": "[Shieber et al. 89] S. M. Shieber, G. van Noord, R. C. Moore, and F. C. N. Pereira, \"A Semantic-fiend- Driven Generation Algorithm for Unification- Based Formalisms\", Proceedings of the AGL, Van- couver, 26-29 June, 1989. [Stallard 87] D. Stallard, \"The Logical Analysis of Lex- teal Ambiguity\", Proceedings of the ACL, Stan- ford, 6-9 July, 1987. [Vaughan et al. 86] M. M. Vaughan and D. D. McDon- ald, \"A Model of Revision in Natural Language Generation\", Proceedings of the ACL, New York, 10-13 June, 1986.", "links": null }, "BIBREF10": { "ref_id": "b10", "title": "The Berkeley UNIX Consultant Project", "authors": [ { "first": "R", "middle": [], "last": "Wilensky", "suffix": "" }, { "first": "D", "middle": [ "N" ], "last": "Chin", "suffix": "" }, { "first": "M", "middle": [], "last": "Luria", "suffix": "" }, { "first": "J", "middle": [], "last": "Martin", "suffix": "" }, { "first": "J", "middle": [], "last": "Mayfield", "suffix": "" }, { "first": "D", "middle": [], "last": "Wu", "suffix": "" } ], "year": 1988, "venue": "", "volume": "88", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "Wilensky 88] R. Wilensky, D. N. Chin, M. Luria, J. Martin, J. Mayfield, and D. Wu, \"The Berkeley UNIX Consultant Project\", Computational Lin- guistics, Vol. 14, No. 4, December 1988.", "links": null }, "BIBREF11": { "ref_id": "b11", "title": "A Parser for Portable NL Interfaces Using Graph-Unification-Based Grammars", "authors": [ { "first": "K", "middle": [], "last": "Wittenburg", "suffix": "" } ], "year": 1986, "venue": "Proceedings of AAAI 86", "volume": "", "issue": "", "pages": "", "other_ids": {}, "num": null, "urls": [], "raw_text": "K. Wittenburg, \"A Parser for Portable NL Interfaces Using Graph-Unification-Based Grammars\", Proceedings of AAAI 86, 1986.", "links": null } }, "ref_entries": { "FIGREF0": { "type_str": "figure", "uris": null, "text": "Lexical Lookup as Decomposition Our extension to the algorithms of [Calder at al. 89] and", "num": null }, "FIGREF1": { "type_str": "figure", "uris": null, "text": "LISP) I I(W ISR CO.PUIER) I", "num": null }, "FIGREF2": { "type_str": "figure", "uris": null, "text": "Figure 3: Decomposition for Metonymy", "num": null }, "FIGREF3": { "type_str": "figure", "uris": null, "text": "Decomposition for a Noun Compound", "num": null } } } }