Using Bidirectional Semantic Rules for Generation 
Jim Barnett and Inderjeet Mani 
Microelectronics and Computer Technology Corporation (MCC) 
3500 West Balcones Center Drive 
Austin, Texas 78759 
U.S.A. 
Abstract 
This paper describes the use of a system of semantic 
rules to generate noun compounds, vague or polyse- 
mous words, and cases of metonymy. The rules are bi- 
directional and are used by the understanding system 
to interpret the same constructions. 
Introduction 
In generation systems that are paired with understand- 
ing systems, bidirectionality is desirable for reasons 
that are both theoretical (a single model of linguis- 
tic behaviour) and practical (shorter development time, 
greater consistency, etc.) 1. Recently, \[Shieber et al. 89\] 
and \[Calder at al. 89\] have presented generation algo- 
rithms that share both semantics and syntax with the 
understanding system. This paper presents an exten- 
sion 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 poly- 
semous words like "have." 
The difficulty with these constructions is that they 
are productive, and cannot be handled easily by simply 
listing meanings in a lexicon. Taking noun compound- 
ing 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 lexi- 
con, 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 compound- 
ing. 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 ap- 
propriate level of generality. 
IF or more detailed arguments along these lines, see 
\[Appelt 87\], \[Shieber 88\], \[Jacobs 88a\]. 
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 for- 
malisms or implementation, so the technique is com- 
patible with a wide variety of theories of the kinds 
of relations that are likely to occur in these construc- 
tions, as in, e.g., \[Finin 80\] for noun compounds and 
\[Nunberg 78\] for oblique reference. 
The Framework 
The algorithms for recognition and generation use 
an agenda-based blackboard for communication and 
control \[Cohen et al. 89\]. 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 represen- 
tation to sets of assertions in the interface language of 
the CYC knowledge base \[Lenat et al. 90\]. 
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 in- 
stantiation of the other set. The intuitive semantics of 
these rules is that any interpretation that matches the 
left-hand side licenses a second interpretation match- 
ing the right-hand side. For example, we can use the 
name of an author to refer to his works ("I read Shake- 
speare"), 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 gen- 
eration 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. 
Generation 
The generator is divided into strategic and tactical com- 
ponents. The former takes a frame as input and cre- 
ates a description of it based on a set of discriminative 
47 
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 descrip- 
tion uniquely identifies the frame with respect to that 
class, otherwise it contains default 'interesting' proper- 
ties. 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.) 
Given this input, the tactical component uses a vari- 
ant 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 cat- 
egorial grammars, most of the syntactic information is 
contained in the lexical definitions of words. For ex- 
ample, 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 con- 
stituent 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.) 
Next we define two relationships between con- 
stituents and goals: first, a constituent matches a goal if 
its semantics subsumes the goal's semantics and its syn- 
tactic 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 ar- 
guments. 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 ar- 
guments 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 pro- 
ceeds 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. 
Extension: Goal Revision 
The algorithm described above assumes a fixed set of 
choices in the lexicon. It can generate metonymic ex- 
pressions 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 alterna- 
tive 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 ex- 
pression with the desired meaning and thus indirectly 
satisfy the original goal. 
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 de- 
composition, as shown in Figure 3. From this perspec- 
tive, 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. [ 
:o.L I 
(X HRSCOLOR Y) \[ 
(x Isg BOOK) I (Y EOURLS RED) | 
(X HRSCRER/OR Z) I (Z EOURLS MRO) \] 
.t. I (U HRSCOLOR V)l |(X ISR BOOK) | 
\[(X HRSCRERTOR Z)\[ l(V E%URLS RED)\] 
\[(Z EOURLS .BO) I 
Figure 1: Lexical Lookup as Decomposition 
Our extension to the algorithms of \[Calder at al. 89\] 
and \[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 bottom- 
up. The extended algorithm is shown in the Appendix. 
Controlling Rule Application 
The strategic component can control the choice among 
alternatives through its specification of the goal's syn- 
tax. 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 replan- 
ning of the input; for recent work incorporating goal revision 
see \[Vaughan et al. 86\]. 
48 
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 ad- 
jective or preposition). Another result of this default 
ordering is that metonymy will never fire in the ab- 
sence of a syntactic specification since there is always 
another way (unless the lexicon is incomplete) of say- 
ing 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 com- 
ponent 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. 
In best-first mode, substantial improvements in effi- 
ciency 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. 
Generating Noun Compounds 
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 lex- 
ical 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. 
GOAL 
rtP 
(Q CRMRUMLPJIGURGE Z) 
(W ISR COMPUTER) 
(Z EOURLS LIGP) 
I (Z EOURLS LISP) I I(W ISR CO.PUIER) I 
isfy the other. Combining the sub-goal solutions yields 
"Lisp machine" as a solution to the original goal. 
Multiple compounds are handled by repeated invo- 
cations of the rules. Suppose we have a Mechanism- 
Maintenance rule, stating that if "x" denotes a Ma- 
chine and "y" denotes any kind of MaintenanceOpera- 
lion, "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 ref- 
erent Y, the maintenance rule will eventually fire, gen- 
erating 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 re- 
pair", with the left-branching structure \[\[Lisp machine\] 
repair\]. 
For an example of a right-branching compound, sup- 
pose 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 Com- 
puter)(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 
\[Symbolics \[Lisp machine\]\]. 
Generating Metonymic References 
I GORL ~ ISR BOOK) (X HRSCRERTO~ ¥) (Y EOURLS JRMESJOYCE) I 
Figure 3: Decomposition for Metonymy 
Figure 2: Decomposition for a Noun Compound 
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 try- 
ing 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 
49 

rule, we need to compute the inverse of the relation. 4 
To do this we reverse the order of the statements and re- 
place each Bind statement (which computes a relation 
between variable bindings) with its inverse. Here we 
rely on the fact that the CYC KB automatically main- 
tains 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 in- 
verse of HasGreator, then the inverse of (Bind Z (X 
CreatorOf)) is simply (Bind X (Z HasCreator)). 
A few more details are necessary to complete the im- 
plementation. First, we define tlie relation Instances, 
which maps from classes to their elements, as the in- 
verse of ISA. Next we define a concatenation operator 
+ on relations, so that (Z (Instances + ttasGreator)) re- 
turns 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 under- 
standing patterns for the Artist rule are given below: 
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)(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 ex- 
pression 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 lexi- 
cal 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 Fil- 
ter 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 re- 
ferring to a Book. 
The rule format is similar for noun compounds, ex- 
cept that there are two input patterns (in the forward 
direction) and a single output pattern. During under- 
standing, 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 there- 
fore guaranteed to have a unique inverse. 
5The inverse of (rl + r2) is ((inverse r2) + (inverse rl)). 
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 instan- 
tiated patterns which the generation routine then uses 
as new goals. 
Related Work 
A variety of systems have used rules of the kind 
we are considering, either explicitly or implicitly, 
for use in understanding compounds, vague expres- 
sions, and metonymy, for example, \[DaM et at. 87\], 
\[Hobbs et al. 88\], \[Grosz et at. 85\], \[Stallard 87\], but 
no mention is made of reversing these rules for gen- 
eration. 
A number of systems generate compounds, but 
most apparently do so using either phrasal lexi- 
cons (e.g., \[Hovy 88\], \[Jacobs 88b\], \[Wilensky 88\]), or 
multiple lexical senses (e.g., \[Pustejovsky et at. 87\], 
\[Nirenburg et al. 88\]), rather than rules of the sort we 
propose. Other generation systems apparently con- 
struct noun compounds via specialized (uni-directional) 
strategies specified in the interface to the tactical com- 
ponent \[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. 
Discussion 
The use of semantic rules seems to us to handle most of 
the technical problems in providing an economical, bi- 
directional treatment of a variety of non-literal and/or 
vague constructions. At the heart of any reversible sys- 
tem is the notion of being able to run mappings for- 
wards or backwards, so that, for example, the under- 
standing and generation lexicons are inverses of each 
other. These rules are a natural extension of this mech- 
anism 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 rela- 
tion 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 sub- 
goal, instead of satisfying it immediately in the man- 
ner of Figure 1. Finally, these rules do not commit us 
to any particular analysis of the constructions in ques- 
tion (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. 
51 
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 strate- 
gic component can force the use of metonymous expres- 
sions 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 ex- 
treme uses, it may have a poetic or humorous force. 
To use metonymy, compounds, or other vague expres- 
sions 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 al- 
ready been described than when used to introduce new 
ones. If "an Orris fishing rod" has already been men- 
tioned, 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 com- 
prehensive model of communication. 
Acknowledgments 
We are grateful to Elaine Rich for comments on an ear- 
lier draft of this paper. 
Appendix: Generation Algorithm 
The 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 pseu- 
docode. We denote local variable assignment as X := 
Y, with scope extending to the immediate containing 
construct. Destructuring by pattern matching is al- 
lowed, 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 so- 
lution, finding any subsequent solutions on backtrack- 
ing. The function choose-tp-dn-operatio, heuristically 
picks the best operation based on the goal. The func- 
tions match and satisfy are as defined earlier. The 
functions apply-unavy-bup-rule and apply-bi.avy-bup- 
rule constitute the rule application interface to gram- 
mar rules; similarly, the functions apply-uuary-tp-dn- 
rule and apply-binary-tp-d.-rule constitute the rule ap- 
plication 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(<lef$-subgoal, right-subgoal> := 
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). 

References 
\[Appelt 83\] D. E. Appelt, "Telegram: A Grammar For- 
malism For Language Planning", Proceedings of 
the ACt, M.I.T., 15-17 June, 1983. 
\[Appelt 87\] 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. 
\[Dahl 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. 
\[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. 
Bole, eds., Natural Language Generation Systems, 
Springer-Verlag, 1988. 
\[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. 
\[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. 
\[McKeown 82\] 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. 
\[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. 
\[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. 
\[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. 
\[Wittenburg 86\] K. Wittenburg, "A Parser for Portable 
NL Interfaces Using Graph-Unification-Based 
Grammars", Proceedings of AAAI 86, 1986. 
