Feature Structure Based 
Semantic Head Driven Generation 
Gendchiro KIKUI 
ATR Interpreting \]~elephony Research Laboratories 
2 2 IIikari dai, Seika-cho, Soraku-gun, Kyoto (;19 02 JAPAN 
kikui@atr- la.atr.co.jp 
Abstract 
This paper proposes a generation method for 
feature-structured)ased unification grammars. 
As comlx~red with fixed ~rity term notation, fea- 
ture structure notation is more tlexible for repre- 
senting knowledge needed to generate idiom~ttic 
structures as well as genem~l constructions. The 
method enables feature strncture retrieval via 
nmltiple indices. The indexing mechanism, when 
used with a semantic head driven generation al- 
gorithm, attains efficient generation even when 
a large amount of generation knowledge must be 
considered. Our method can produce all possi 
ble structures in parNlet, using structure sharing 
among ambiguous substructures. 
1 Introduction 
PracticM generation systems must lnwe linguistic 
knowledge of both specilic expressions like idioms 
and generM grammatical constructions, ;rod ttmy 
should efgtciently produce sm'face strings apply- 
ing that knowledge \[\[\]\[2\]. 
In order to satisfy the first requirement, our 
system employs a set of trees annotated with 
fe,~ture structures to represent generation knowl- 
edge. l:;ach tree represents a t?agment of a syn- 
tactic strncture, and is paired with a semantic 
feature structure. We can describe idiomatic 
eonstructions, by making a tree which cont~tins 
lexical specifications and is paired with a specilie 
rather than general semautic structure. Because 
feature structures allow partial speeiiicatiom we 
can encode generation knowledge r;mgiug over 
multiple levels of generality in a. uniform way. 
llowever, notice that this property will be re- 
stricted if we use DCG or (tixed arity) term 
notation 1 Suppose there is a generation 
knowledge structure whose syntactic part is 
"go on foot". 'rim feat, tu'e structure notation 
of its semantic part will be sonmthing like: 
~The flexibility of structure notation colnpated Lo tetln 
notation is also discussed il~ \[4\]. 
\[ \[Rein GO\] 
\[Agent ?agent \[\] \] 
\[Instrument FOOT\]\]. 
while the term notation is : 
(1) 
instrument(go(Agent), foot) (2) 
These two notations seem to be equivalent, but 
there is a cruciN diflerence. A generation knowl- 
edge structure containing the fe~tture-based se- 
lnantics will still be unifiable even if the seman- 
tic input to be unified contains additional ma- 
terial. Thus the knowledge structure will be 
discovered and its syntactic information can he 
used for generation. By contrast, a term-based 
input with additiona.1 elements would not unify 
with the term-based semantic structure shown 
above. It would thus be necessary to create ad- 
ditional generation structures containing distinct 
(though partly overlN)ping) term-based seman- 
tic structures. Such additional structures are re- 
dundant ~tn(l cause superfluous output. 
For example, consider the a,ugmented feature 
structure (3). 
\[ \[Rein ~o\] 
\[Agent Ken\] 
\[Instrument FOOT\] 
\[Time I0 : OOmn\] \] (3) 
it will indeed nnify with (1) above. But term- 
based input semantic structure (4) will not unify 
with term-based semantic structure (2). 
instrument(time(go(ken), 10:00am), foot). 
(4) 
To unifv (2), semantic ,structure (5) would a.lso 
be required. 
time(instzument(go(ken), foot), 10:00ma). 
(5) 
AcrEs DE COLING-92. NANTES. 23 28 AOt~q" 1992 3 2 PROC. OI; COLING 92. NANTES. AUG. 23 28. 1992 
For this reason, our generation knowledge con- 
sists of trees represented as feature structures. 
A tree can be substituted for a leaf node of as- 
other tree to form a larger structure. Thus, tile 
tree can be regarded as a rule in a context-free 
feature-structure-based unification grammar. 
The second requirement for a generation sys- 
tem is efficient creation of syntactic structures. 
This is the main topic of this paper. Our system 
is based upon Semantic }lead Driven Generation 
\[6\], which is an efficient algorithm for unilication 
based formalisms. However, this algorithm re- 
quires some additional mechanisms to efficiently 
retrieve relevant generation knowledge, because 
feature structures can not be easily indexed. 
The algorithm presented here uses a nmltiple 
index network of feature structures to efficiently 
choose relevant generation knowledge from the 
knowledge base. The algorithm "also uses an hy- 
pothetical node so as to efficiently maintain am- 
biguous structures during generation. 
2 Phrase Description(PD) 
Generation knowledge is represented as a set of 
trees aunotated with feature structures, l,',ach 
tree is called a Phrase Description (PD). 
ALl example of a l)D is shown in Figure.1. 
Structure: 
(S AUX (NP PRON) VP) 
Annotation: 
(S \[\[syn \[\[cat S\] \[inv +\]\]1 
\[sem \[\[reln REQUEST\] 
\[agon *SP*\] 
\[recp *HR*\] 
\[obje ?ACTION\]\]\]\]) 
(AUX \[\[syn \[\[cat AUX\] \[lex "would"\] 
\[v-morph PAST\]\]\]\]) 
(NP \[\[syn \[\[cat NP\] \[case NOM\]\]\]\]) 
(PRON \[\[syn \[\[cat PRON\] \[case NOM\] 
\[lex "you"\]\]\]\]) 
(VP \[\[syn \[\[cat VP\]\[v-morph BSE\]\]\] 
\[sem ?ACTION\]J) 
Figure 1: an example of a PD 
A PD consists of two parts: a structure defini- 
tion and feature structure annotation (Structure 
a.nd Annotation in Figure 1). 
The structure definition defines tile structure 
of a tree by using a list in which the first ele- 
ment corresl)onds to the mother node and tile 
rest of the elements correspond to daughters. 
l';ach daughter may t)e a tree rather than a sin> 
pie node. 
Acres DE COLING-92, NANTes, 23-28 AO6-r 1992 3 3 
The annotation part specifies the feature 
structure of each symhol appearing in the struc- 
ture definition. A feature structure description 
can contain tags or variables (symbols with "?" 
as a prefix in the figure), The scope of a tag in 
a PD is the entire PD. 
Each node should have a semmltic and syntac- 
tic feature structure. The semantic feature on 
the root node of a PD represents the semaattics 
of the PD; thus we call it the semantic structure 
of the PD. 
Although the description represents a tree, it 
is the same ms for a (partial) derivation structure 
of a unification-l)ased CFG, because tile current 
system does not allow adjoining operations. If 
the structure definition of every PD is restricted 
to mother-daughter relations only, the PD set is 
strictly equivalent to a unification-based CFG. 
3 Generation Algorithm 
Our algorithm is aal efficient extension of Semaat- 
tic Head Driven Generation. 3?he major exten- 
sions are: 1) it handles feature structures di- 
rectly, and 2) it creates all possible phrase struc- 
tures in parallel. These extensions are embodied 
mainly in the t'l) activation and ambiguity han- 
dling mechanisms discussed in this section. 
3.1 Overview of the algorithm 
The main part of the generation process is expan- 
sion process, which iterates through expanding 
node selection, activation, prccombination, and 
application, using an e~Tmnding node agenda. 
Input to the process is a feature structure con- 
raining syntactic, semantic and pragmatic fea- 
tures as an initial constraint on the root node. 
q'he Cxl)auding node agenda contains tim un- 
lexicalized leaf nodes of the tree under creation. 
At the beginning of the process, it conta.ins only 
one node, which has the feature structure giveu 
as an initial constraint. 
The expanding node selection step picks up 
one node, say expanding node, from the agenda. 
If no node is picked ill) , the expaa~sinn process 
stops. 
The PD activation step activates all PD's 
whose senlantic strlLetures s~tlJs~tme the seman- 
tic structure of the expanding node. 
The precombination step makes PD sequences 
from activated PD's to satisfy some constraints. 
The application step instantiates the PD se- 
quence(s) and applies it to tile expanding node. 
Paoc. oe COLING-92, NAm'ES, AU~. 23-28, 1992 
PD1 PD2 
v3 v4 v2 
Figure 2: an example of dags 
It also pushes unlexicMized leaf nodes into the 
expanding node agenda. 
i//#...':.-"'">e 4a 
PDI PD2 l 
0 path node ~ feature arc 
.... value arc pd node 
-~ tag arc 
3.2 Expanding Node Selection 
The expanding node selection step is for fetching 
one node from the expanding node agenda. From 
among the nodes whose semantic feature has 
been instamtiated, one is chosen. In this step, if 
tile fetched node satisfies some termination con- 
ditions (if~ for instance, it satisfies tile conditions 
for slash terminatim0, the node is discarded (i.e., 
not expanded any more). If the agenda is empty 
or contains no node with an instantiated seman- 
tic feature, the expansion process stops. 
3.3 Activation 
This step is responsible for selecting all PD's 
whose semantic structures subsume the semantic 
structure of an expanding node. The selection is 
done by traversing a multiple index network of 
PD's called the PD net. 
3.3.1 Compiling PD's 
A set of PD's are pl'e-compiled into a PI) net. 
Suppose there are two PD's whose sema~ntic 
structures 2 are defined as the dags (i.e. di- 
rected acyelic graphs) in Figure 2. in the fig- 
ure, fa,fl),fc,.., and vl,v2,., represent arc babels 
(feature names) and atomic values respectively. 
These PD's are coinpiled to the PD net shown in 
Figure 3. 
The uet has two kinds of nodes: path 
nodes@i), and PI) nodes (PDj). These nodes 
are linked by three kinds of labeled directed arcs: 
2The semantic feature of a PD. is a semantic feature 
on the root node of the PD 
Figure 3: an example of PD net 
feature arcs(bold lines), vMue arcs(dashed), and 
tag arcs(with arrows). 
A path node is used to represent a particular 
feature path in one or more feature structure. 
As shown in Figure 3, path nodes are linked by 
bold feature arcs to form a tree. The sequence 
of arc labels from the root path node to a path 
node Pl is the path of Pi. \[It Figure 3, p3 and p5 
show paths (Po N) and (re fd) respectively. 
Each PD node (rectangle) corresponds to a 
particular PD, which may have value ares and 
tag arcs. 
• Value Arcs: Which PD's contain which atomic 
vNues along certain paths ? 
A PD node may be linked to path nodes with 
value ares. 
If a (rectangular) PD node is linked to a. 
(round) path node pn with a dashed value are 
labeled v, then following the path leading to pn 
yields atomic value v in that PD. 
Consider the dashed value are vl in Figure 3. 
It indicates that following path fa in PDI yiehls 
an atomic value vl. This is just tim situation 
depicted in Figure 2. 
• Tag Arcs: In a given PD, which paths share a. 
cel't~in feature structure as a vaJue ? 
A PD node may also be linked to path nodes 
with tag arcs. 
If lowo tag arcs have the same label and they 
cdnnect ;~ PD node to two path nodes, say pnl 
and pn2, then tim feature structure of that PI) 
has a substrm;ture which is the value of both 
paths, that of phi and pn2. 
Am~s DE COLING-92, N^NTES, 23-28 ao~r 1992 3 4 Proc. OF COL/NG-92, NANTES, AU6. 23-28, 1992 
t, br example, the two tag arcs from rectangular 
PDI node labeled "tl" in Figure 3 show that 
the semantic structure of PD1 has a substructure 
serving as the vMue of (~) and (fc). 
3.3.2 Traversing the PD net 
The data structure of nodes and arcs are shown 
ill. Figure 4. 
+ ........ + + ........... + 
I PD I I label I + ........ + + ........ + 
+ ........... + 
Ivalues I ltagarcs I Idestinationl 
+ ........ + + ........ + + ........... + 
If eatures I I valueNuml (c) arc 
+ ........ + + ........ + (feature arc, Idagstorel \[status \] value arc, 
+ ........ + + ........ + 
(a) P node (b) PD node path arc) 
Figure 4: Node and Arc structures 
A path node has three slots: values, features, 
oatd dagstore. The values slot and the arcs slot 
contain value arcs and feature arcs respectively. 
The dagstore stot is initially empty; later it holds 
a pointer to a dag which passed the path node. 
Each PD node has a PD slot, a tagares slot, 
a valueNum slot, and a status slot. The PD slot 
contains a pointer to the represented PD itself. 
The tagarcs slot contains the data structure of 
the tagarcs (see below). The valueNum slot has 
the number of value arcs to the PD node. For 
example, the value of the number slot of PD1 
node in Figure3 is 3, because the node has one 
value a.rc labeled vl and two value arcs labeled 
vl. The status slot holds integer and is initially 
set to 0. 
Every type of arc has two slots, 'label' and 
'destination'. 'Label' is an atomic symbol which 
labels the arc, and 'destination' is a pointer to 
the node which is the destination of the arc. 
We use the PD net as a dataltow net. The en- 
try point of the net is the root path node amd the 
token which flows is a dag of a semantic feature 
structure. 
The action of a path node is shown in Figure 
5. "faihn'e" means there is no PD whose seman- 
tic structure subsumes the given dag. Thus the 
entire retrieval process fails. 
The action of a 1)D node is shown in Figure 
6. The status is incremented each time the node 
receives a tokeu. As a result, if all atomic values 
in tl,e semantic structure of the PI) are satisfied, 
the status becomes equM to the valueNum (that 
is the nulnber of atomic values). Once this is 
detected, then uuifiability of shared structure is 
checked by cMling the tagtcst procedure. 
Tagtest tests unifiability of the dags in the dag- 
stores of p(ath) nodes connected by tag arcs with 
the same label. Iu Figure 3, if the status of PD1 
becomes 3 and if the dag in p2 and the dag in 114 
are identical, then the PD becomes active. That 
is, the PD has been found to subsume the gen- 
eration input. It may or may not actually be 
applied, depending on later events. 
PROCEDURE PDnodeAction(pdNode, value) 
pdNode.stat, us ~ pdNodc.status + 1 ; 
IF pdNode.status = pdNode.valueNum 
and tagtest(pdNode.tagarcs) = T THEN 
activate(pdNode.PD) ; 
Figure 6: Procedure of a PD node 
If there is a PI) node whose wdueNums is 0 
(i.e. No a,tomic value is specified iu the semantic 
structure), node action of the PD node is invoked 
after ¢la.taflow is terminated. 
PROCEDURE PathNodeAction(pathnode, dag) 
pathnode.dagstore ,-- tile pointer of dag ; 
IF dag is atomic value type THEN 
validValueArcs +-- {arc \[ arc E pathnode.values, arc.label = (lag.value} ; 
IF validValueAres :~ ¢ THEN 
FOR EACH arc IN validValueArcs DO 
PDnodeAction(are.pdnode, dag) ; 
ELSE failure ; 
ELSE IF dag is complex value type THEN 
FOR EACH arc IN dag.va:ue DO 
IF Searcharc(arc.label, pathnode.featureArcs) 
:~ Nil THEN 
PathNodeAction(Searcharc(arc.label, pathuo(le.featureAras), arc.destin;ttion) ; 
ELSE failure 
Figure 5: Procedure of a path node 
Acres DE COLING-92, NAI'/TES, 23-28 Aour 1992 3 5 PROC. OF COLING-92, NANTES, AUG. 23-28, 1992 
3.4 Precombination 
The precombiuation step is responsible for mak- 
ing sequences of PD's from activated PD's under 
certain constraints. A PD sequence is a rough 
plan for a potential structure which can realize 
a semantic specification of the node being ex- 
panded a. If no sequence is obtained, the am- 
biguity resolution process, discussed later, is in- 
voked. 
We divide PD's into two groups: propagation 
type and non-propagation type. A propagation 
type PD has has one propagation node. A prop- 
agation node of a PD is a leaf node whose se- 
mantic structure is identical with the semantic 
structure of the root node of the PD 4. The rest 
of the PD's, which have no propagation nodes, 
are classified as non-propagation type PD's. This 
distinction is an extension of Shieber's chain rule 
and non-chain rule distinction. 
A PD sequence PD1 ..... PD,~ must satisfy the 
following constraints. 
1. semantic structure sharing constraints 
(a) PDi(1 <_ i < n) is a propagation PD, 
(b) PD~ is a non-propagation PD, 
Under these constraints, the system can 
make a partial phrase structure by unifying 
the propagation node of PDI with the root 
uode of PDi+l. Tile root node of the cre- 
ated structure contains the unified semantic 
structure of all semantic structures of PD's 
in the sequence. 
2. local unifiability constraints 
(a) the root node of PDI is unifiable with 
tile expanding node 
(b) t>Di and t)Di+l are connectable 
where PDI is connectable to PD 5 if PDI is a 
propagation P\]), and tim propagation node 
of PDi is unitiable with the root node of 
PDj. 
These constraints are necessary conditions 
for unifiability throughout the entire PD se- 
quence, which is called the global nnifiability 
of a PD sequence. In contrast to such global 
uni/iability constraints, the local vnifiability 
can be pre-computed, or compiled, before 
generation process. 
aA PD sequence is roughly corresponds to a bottom-up chum 
in \[6} 
~Our current system does not allow PD's with multiple 
semantic head 
4. 
covering constraint 
Let fsl be the unified semantic structure of 
all semantic structures of PD's in tile se- 
quence. Fsl must contain every top feature 
of the semantic structure of the expanding 
node, where a top feature of a feature struc- 
ture is defined as a top-level feature name. 
The covering constraint ensures complete 
generation \[6\]. If the constraint is not saris- 
fled, a given semantic structure may not be 
completely realized in the generation result. 
For example, if all input semantic strucure 
is (3) (in Section 1) and the unified seman- 
tic structure of a PD sequence is (1), then 
the resulting PD sequence lacks the locative 
phrase for the "time" feature, which will not 
appear in the generation result. 
disjointness constraints 
For each PD (PDi), there is no other PD 
(PDj(i # j)), such that PDI has a top arc 
whose label is included in the set of top arcs 
of PDj. The definition of top arc is given 
above. 
If this constraint is not satisfied, the genera- 
tion result may contain duplicated or invalid 
expressions. For example, if a PD sequence 
contains two distinct PD's each of which is 
for a locative adjunct and has a "time" fea- 
ture on the top level, the generation result 
will have two locative adjuncts for one se- 
mantic feature (i.e. tile "time" feature). 
The disjointness constraint also ensures 
compaetgeneration. Suppose a coherent and 
complete generator produces a string w, and 
the grammar assigns a semantic structure 
fso to w using a set of rules R. String w is 
minimal if every sub-structure of fso is sup- 
plied from one rule in R. The generator is 
compact if any string w is minimal. 
Ill general, completeness, &lid conlpactness 
cannot actually be judged until the entire gen- 
eration fiulshes. Thus the last two constraints (3 
and 4) do not reaiiy guarantee completeness and 
compactness; rather, they help to limit search 
space in a practical way. 
3.5 PD Application 
The PD application step is responsible for creat- 
ing phrase structure(s) fl'om PD sequence(s) and 
attaching them to the expanding node. In this 
section, we restrict ourselves to the simple case 
ACRES DE COLING-92, NAN'YES, 23-28 AOt~T 1992 3 6 PROC. OF COLING-92, NANTES, AUG. 23-28, 1992 
such that there is only one PD sequence obtained 
during the previous step. The case of multiple 
PI) sequences, (i.e., generation ambiguity), will 
be discussed in the next section. 
First, the module connects all PD's in the PD 
sequence PDI...PD,, by unifying the propagation 
node of PDi with the root node of PDI+1. All 
unification operations are quasi-destructive, or 
temporal \[7\]. The result of the unification is valid 
until the module copies it (see below). 
If this entire unification process succeeds (i.e., 
if every PI) in the sequence can indeed be uni- 
fied, and the sequence thus proves to be globally 
unifiable; see 3.7), then the module makes a copy 
of the unified PD sequence. Otherwise expansion 
failure (see next section) is signified. The copy, 
which is a phrase structure tree, is called an in- 
stance of the PD sequence. 
Then the module attaches (unifies) the instan- 
tiatted PD sequence to the expanding node. 
Finally, the system stores in the exl)andiug 
node agenda leaf nodes of expanded structures 
which have no lexieal feature values.. 
3.6 Ambiguity Handling 
3.6.1 Ambiguity packing 
If multiple PD sequences are applicable to an ex- 
panding node, the substructure of the expanding 
node can not be uniquely determined, because 
each PD sequence indicates only an hypothesis 
for' the potential substructure. 
The system maintain these hyl)otheses in a 
special hypotheses slot on the undetermined ex- 
panding node. 
For each PD sequence, a copy of the expanding 
node (:ailed an hypothesis node is created. These 
copies are stored into the hypotheses slot of the 
original expanding node. Then the system ap 
plies each PD sequence to the corresponding hy- 
pothesis node, as described in the previous sec- 
tion, and continues expansion. 
In Figure 7, three suhtrees in the "hypo" slol. 
on the undetermined node have been created for' 
the hypothetical Pl) sequences. 
The hyl)othetical PI) sequences are not unb 
lied with the original expanding node, but unb 
tied with copies of the expanding node. This pre 
vents tire original feature structure of the unde- 
termined node from being modilied by further 
expansion of the hypothetical structures (T I-T3 
in Figure 7). 
q'he further expansion sometimes makes an 
hypothesis node inconsistent with the original 
vl, \[inq 
t0~" p0-------_~0p: 
hypothesis T ~,,~'" -'" .,.-" -. .j 
nodes ~ VP1 ~"~VP2 VP3 P' 
Figure 7: generation ambiguity 
node. This is detected in the ambiguity reso- 
hltion process described in the next section. 
3.6.2 Expansion Failure and Ambiguity 
ILesolution 
Expansion failure occurs when: 
1. \]to PD is activated in the PD activation, or 
2. no PD sequences are obtained in the pre 
combination, or 
3. no PI) sequences satisfy global connectabil- 
ity in the application. 
The failure signifies that the feature strncture 
of the current exl)anding node is inconsistent 
with a set of Pl)'s given as generation knowl- 
edge. 
The module searches tbr the ne;~rest (i.e., low- 
est) hypothesis node (Nh) dominating the failed 
expanding node and deletes Nh fi'om the hy- 
potheses slot containing it. 
If the number of hyl)othetical structures in the 
hyl>otheses slot of a.n undetermined re>de (N,,) 
hecomes one, then N,~ and the root node. of the 
remaining structnre in the hypotheses slot are 
unified. If the unilication f~tils, amlriguity resoh> 
tion continues recursively upw~rd. 
An examt)le of ambiguity resolution is illus 
trated in Figure 8. The values of tire hyt)othe- 
ses slot of node VI' are the hypothetical nodes 
VPl, VP2, and vt'3, corresponding to hypothet 
ical trees TI, T2, 'I'3 respectively. If expansion 
failure occur in T I and '1'2, VP1 ;~nd V I'2 are 
removed from the hypothesis slot. Then, Vl'3 is 
unitied with VP, because there is only one hy 
pothesis node left in the slot VP node. 
If there is no hypothesis node dominating the 
failed expansion node, the entire generation l)r~)- 
cess fails. 
AcrEs DE COLING-92, NAI~'aT..S, 23-28 AOI\]'r 1992 3 7 I'ROC. OF COLING-92, NANTF.S, AUr3. 23-28, 1992 
Nh 
unify 
....... 
VP1 VP2 VP3 
perform adjunct operation \[9\]. 
The algorithm is implemented in SL-Trans, a 
spoken language translation system \[8\]. 
Acknowledgments 
The author would like to thank M0zk Seligma~t 
for helpful comments on this paper and also 
would like to thank Akira Kurematsu, Tsuyoshi 
Morimoto and other members of ATR for their 
constant help and fruitful discussions. 
Figure 8: an illustration of generation ambiguity 
resolution 
3.7 Postprocess 
Expansion halts when no node is selected in the 
expanding node selection step. This does not 
necessarily mean the agenda is empty, because 
there m~y be some nodes without instantiated 
smnantic structure. 
ltow do such semantically empty nodes arise? 
The problem is that feature structnres within hy- 
potheticM nodes are not allowed to unify with 
the feature structure on the "real" dominating 
node. 
The solution is: for each hypothetical node, 
we create a complete tree using copies of the 
"real" dominating structure, Feature structures 
can then be permitted to unify with dominating 
structures. Then, the system collects all unlexi- 
calized leaf re)des as initial values of the expand- 
ing node agenda and starts the normal expansion 
loop again. 
4 Concluding Remarks 
A semantic head driven generation method based 
on feature structures is proposed in this pa- 
per. This method efliciently generates all possi 
ble phrase structures fl'om a given semantic fea- 
ture structure. The method involves multiple 
indexing of feature structures and a precombi- 
nation nlechanisn\]. These lnechanisnls constrain 
applicable gralnmatical knowledge beR)re instan- 
tiation; thus the method eliminates the copying 
of fegture structures, which consunles conlputillg 
resources. 
The proposed grammar notation is appropri- 
ate for describing idiomatic phrase structures 
easily. To make the best use of the notation, 
we are extending the Mgorithm so that it can 
AcrEs De COLING-92, NAmes, 23-28 AO13"r 1992 3 8 

References 

\[11 Hovy, E.H., "Generating NaturM Language 
Under Pragmatic Con- 
stralnts",Ph.D.Dissertation, Yale Univ., 1987 

\[2\] Jacobs, P.S., "A generator for natural lan- 
guage interfaces", In D.l).McDonald et al., ed- 
itors, NaturM Language Generation Systems, 
Chapter 7, Springer-Verlag, 1988 

\[3\] Shieber,S. M, "An introduction to 
Unification-Based Approaches to Graznmar', 
CSLI, 1986 

\[4\] Knight, K., "Unification: A Multidisci- 
plinaxy Survey", ACM Computing Surveys, 
VoL21, No.i, 1989 

\[5\] Pollard,C. et ah, "Information-ba.sed Syn- 
tax and Semantics Volume 1 Fundamentals", 
CSLI, 1987 

\[6\] Shieber, S.M. et al., "A Semantic-Head- 
Driven Generation Algorithm", In Proceed- 
ings of 27th ACL, t989 

\[7\] Tomabechi, H., "Quasi-Destructive (\]raph 
Unification", In Proceedings of 29th ACL, 
1991. 

\[8\] Morimoto, "17., et a.l. "A Spoken Language 
Translation System : SL-TRANS2". In Pro- 
ceedings of COLING'92, 1!)92. 

\[9\] Vijay-Shanker, K. et al., "Feature Structure 
Based Tree Adjoining Grammars", in Pro- 
ceedings of COLING'88, 1988 
PROC. OF COLING-92, NANTES, AUG. 23-28, 1992 
