Preserving Semantic Dependencies in 
Synchronous Tree Adjoining Grammar* 
William Schuler 
University of Pennsylvania 
200 South 33rd Street 
Philadelphia, PA 19104 USA 
schuler@linc, cis. upenn, edu 
Abstract 
Rambow, Wier and Vijay-Shanker (Rainbow et 
al., 1995) point out the differences between TAG 
derivation structures and semantic or predicate- 
argument dependencies, and Joshi and Vijay- 
Shanker (Joshi and Vijay-Shanker, 1999) de- 
scribe a monotonic compositional semantics 
based on attachment order that represents the 
desired dependencies of a derivation without un- 
derspecifying predicate-argument relationships 
at any stage. In this paper, we apply the Joshi 
and Vijay-Shanker conception of compositional 
semantics to the problem of preserving seman- 
tic dependencies in Synchronous TAG transla- 
tion (Shieber and Schabes, 1990; Abeill~ et al., 
1990). In particular, we describe an algorithm 
to obtain the semantic dependencies on a TAG 
parse forest and construct a target derivation 
forest with isomorphic or locally non-isomorphic 
dependencies in O(n 7) time. 
1 Introduction 
The primary goal of this paper is to solve the 
problem of preserving semantic dependencies in 
Isomorphic Synchronous Tree Adjoining Gram- 
mar (ISTAG) (Shieber, 1994; Shieber and Sch- 
abes, 1990), a variant of Tree Adjoining Gram- 
mar (Joshi, 1985) in which source and target 
elementary trees are assembled into isomorphic 
derivations. The problem, first described in 
Rambow, Wier and Vijay-Shanker (Rainbow et 
al., 1995), stems from the fact that the TAG 
derivation structure - even using a flat adjunc- 
tion of modifiers (Schabes and Shieber, 1994) 
- deviates from the appropriate dependency 
*The author would like to thank Karin Kipper, 
Aravind Joshi, Martha Palmer, Norm Badler, and 
the anonymous reviewers for their valuable comments. 
This work was partially supported by NSF Grant 
SBP~8920230 and ARO Grant DAAH0404-94-GE-0426. 
structure in certain cases. This can result in 
translation errors. 
For example, if we parse sentence (1), 
(1) X is supposed to be able to fly. 
using the trees in Figure 1, we get the following 
derivation:l 
a:fly I 
131 :be-able-to(VP) 
I j32:is-supposed-to(VP) 
with the auxiliary is-supposed-to adjoining at 
the VP to predicate over be-able-to and the aux- 
iliary be-able-to adjoining at the VP to predi- 
cate over fly. If we then try to assemble an iso- 
morphic tree in a language such as Portuguese 
(which makes less use of raising verbs) using 
the ISTAG transfer rules in Figure 2, we will be 
forced into an ill-formed derivation: 
: voar I 
;31 :~-capaz-de (VP) I 
/~2 :~-pressuposto-que (S ?) 
because the raising construction is-supposed- 
to translates to a bridge construction d- 
pressuposto-que and cannot adjoin anywhere in 
the tree for ~-capaz-de (the translation of be- 
able-to) because there is no S-labeled adjunction 
site. 
The correct target derivation: 
a:voar 
~l:~-capaz-de(VP) ~2:~-pressuposto-que(S) 
1The subject is omitted to simplify the diagram. 
88 
VP VP 
Vo VP Vo VP 
is Vo VP \[ 
\[ ~ able Vo VP* supposed Vo VP* \[ 
\[ to to 
S 
NP$ VP 
I 
Vo I 
fly 
Figure 1: Sample elementary trees for "supposed to be able to fly" 
which yields the translation in sentence (2), 
(2) t~ pressuposto que X 6 capaz de voar. 
is not isomorphic to the source. Worse, this 
non-isomorphism is unbounded, because the 
bridge verb pressuposto may have to migrate 
across any number of intervening raising verbs 
to find an ancestor that contains an appropriate 
adjunction site: 
a:fly a:voar 
I 
fll :able(VP) \[ fll :capaz(VP) fln:press•(S) 
• , . l 
I , o. 
fin--1 :going(VP) I \[ fin--1 :vai(VP) 
fln:supp.(VP) 
This sort of non-local non-isomorphic transfer 
cannot be handled in a synchronous TAG that 
has an isomorphism restriction on derivation 
trees• On the other hand, we do not wish to 
return to the original non-local formulation of 
synchronous TAG (Shieber and Schabes, 1990) 
because the non-local inheritance of links on 
the derived tree is difficult to implement, and 
because the non-local formulation can recog- 
nize languages beyond the generative power of 
TAG. Rambow, Wier and Vijay-Shanker them- 
selves introduce D-Tree Grammar (Rambow et 
al., 1995) and Candito and Kahane introduce 
the DTG variant Graph Adjunction Grammar 
(Candito and Kahane, 1998b) in order to solve 
this problem using a derivation process that 
mirrors composition more directly, but both in- 
volve potentially significantly greater recogni- 
tion complexity than TAG. 
2 Overview 
Our solution is to retain ISTAG, but move 
the isomorphism restriction from the deriva- 
tion structure to the predicate-argument at- 
tachment structure described in (Joshi and 
Vijay-Shanker, 1999). 
This structure represents the composition of 
semantic predicates for lexicalized elementary 
trees, each of which contains a 'predicate' vari- 
able associated with the situation or entity that 
the predicate introduces, and a set of 'argument' 
variables associated with the foot node and sub- 
stitution sites in the original elementary tree. 
The predicates are composed by identifying the 
predicate variable in one predicate with an ar- 
gument variable in another, so that the two vari- 
ables refer to the same situation or entity. 
Composition proceeds from the bottom up on 
the derivation tree, with adjuncts traversed in 
order from the lowest to the highest adjunction 
site in each elementary tree, in much the same 
way that a parser produces a derivation. When- 
ever an initial tree is substituted, its predicate 
variable is identified in the composed structure 
with an argument variable of the tree it substi- 
tutes into. Whenever an auxiliary tree is ad- 
joined, the predicate variable of the tree it ad- 
joins into is identified in the composed struc- 
ture with one of its own argument variables. In 
cases of adjunction, an auxiliary tree's seman- 
tics can also specify which variable will become 
the predicate variable of the composed struc- 
ture for use in subsequent adjunctions at higher 
adjunction sites: a modifier auxiliary will re- 
turn the host tree's original predicate variable, 
and a predicative auxiliary will return its own 
predicate variable. 2 Since the traversal must 
2See (Schabes and Shieber, 1994) for definitions of 
modifier and predicative auxiliaries. 
89 
VP 
Vo VP 
is Vo VP 
supposed Vo VP* 
I to 
VP 
Vo VP 
be Vo VP 
able Vo VP* I 
to 
S 
Vo S 
Vo S 
pressuposto Vo S* I 
que 
VP 
Vo VP 
Vo VP 
capaz Vo VP* I 
de 
S 
NP$ VP 
I Vo 
t fly 
S 
NP.I. VP I 
Vo 
i voar 
Figure 2: Synchronous tree pairs for "supposed to be able to fly" 
proceed from the bottom up, the attachment of 
predicates to arguments is neither destructive 
nor underspecified at any stage in the interpre- 
tation. 
For example, assume the initial tree a:fly has 
a predicate variable s\], representing the situa- 
tion of something flying, and an argument vari- 
able xl, representing the thing that is flying; 
and assume the predicative auxiliary tree/31 :be- 
able-to has a predicate variable s2, represent- 
ing the situation of something being possible, 
and an argument variable s3, representing the 
thing that is possible. If fll is now adjoined 
into a, the composed structure would have sl 
identified with s3 (since the situation of flying 
is the thing that is possible), and s2 as an over- 
all predicate variable, so if another tree later 
adjoins into this composed structure rooted on 
a, it will predicate over s2 (the situation that 
flying is possible) rather than over a's original 
predicate variable sl (the situation of flying by 
itself). Note that Joshi and Vijay-Shanker do 
not require the predicate and modifier distinc- 
tions, because they can explicitly specify the 
fates of any number of predicate variables in 
a tree's semantic representation. For simplicity, 
we will limit our discussion to only the two pos- 
sibilities of predicative and modifier auxiliaries, 
using one predicate variable per tree. 
If we represent each such predicate-argument 
attachment as an arc in a directed graph, we can 
view the predicate-argument attachment struc- 
ture of a derivation as a dependency graph, in 
much the same way as Candito and Kahane 
interpret the original derivation trees (Candito 
and Kahane, 1998a). More importantly, we can 
see that this definition predicts the predicate- 
argument dependencies for sentences (1) and (2) 
to be isomorphic: 
¢0:supposed-to ¢0:~-pressuposto-que 
i i ¢1 :be-able-to ¢1 :&capaz-de 
¢2:flY ¢2:voar 
even though their derivation trees are not. 
This is because the predicative auxiliary for 
&capaz-de returns its predicate variable to the 
host tree for subsequent adjunctions, so the aux- 
iliary tree for g-pressuposto-que can attach it as 
one of its arguments, just as if it had adjoined 
directly to the auxiliary, as supposed-to does in 
English. 
It is also important to note that Joshi and 
Vijay-Shanker's definition of TAG composi- 
tional semantics differs from that of Shieber 
9{) 
and Schabes (Shieber and Schabes, 1990) using 
Synchronous TAG, in that the former preserves 
the scope ordering of predicative adjunctions, 
which may be permuted in the latter, altering 
the meaning of the sentence. 3 It is precisely 
this scope-preserving property we hope to ex- 
ploit in our formulation of a dependency-based 
isomorphic synchronous TAG in the next two 
sections. However, as Joshi and Vijay-Shanker 
suggest, the proper treatment of synchronous 
translation to logical form may require a multi- 
component Synchronous TAG analysis in order 
to handle quantifiers, which is beyond the scope 
of this paper. For this reason, we will focus on 
examples in machine translation. 
3 Obtaining Source Dependencies 
If we assume that this attachment structure 
captures a sentence's semantic dependencies, 
then in order to preserve semantic dependencies 
in synchronous TAG translation, we will need to 
obtain this structure from a source derivation 
and then construct a target derivation with an 
isomorphic structure. 
The first algorithm we present obtains se- 
mantic dependencies for derivations by keep- 
ing track of an additional field in each chart 
item during parsing, corresponding to the pred- 
icate variable from Section 2. Other than the 
additional field, the algorithm remains essen- 
tially the same as the parsing algorithm de- 
scribed in (Schabes and Shieber, 1994), so it 
can be applied as a transducer during recogni- 
tion, or as a post-process on a derivation forest 
(Vijay-Shanker and Weir, 1993). Once the de- 
sired dependencies are obtained, the forest may 
be filtered to select a single most-preferred tree 
using statistics or rule-based selectional restric- 
tions on those dependencies. 4 
For calculating dependencies, we define a 
function arg(~) to return the argument posi- 
tion associated with a substitution site or foot 
node ~? in elementary tree V. Let a dependency 
be defined as a labeled arc (¢, l, ~b), from predi- 
cate ¢ to predicate ¢ with label I. 
• For each tree selected by ¢, set the predi- 
cate variable of each anchor item to ¢. 
3See (Joshi and Vijay-Shanker, 1999) for a complete 
description. 
4See (Schuler, 1998) for a discussion of statistically 
filtering TAG forests using semantic dependencies. 
• For each substitution of initial tree a¢ 
with predicate variable w into "),¢ at node 
address U, emit (¢, arg(v , r/), w) 
• For each modifier adjunction of auxil- 
iary tree/3¢ into tree V¢ with predicate vari- 
able X, emit (¢, arg(p, FOOT), X) and set 
the predicate variable of the composed item 
to X. 
• For each predicative adjunction of aux- 
iliary tree /3¢ with predicate variable w 
into tree "),¢ with predicate variable X, emit 
(¢, arg(/3, FOOT), X) and set the predicate 
variable of the composed item to w. 
• For all other productions, propagate the 
predicate variable up along the path from 
the main anchor to the root. 
Since the number of possible values for the 
additional predicate variable field is bounded 
by n, where n is the number of lexical items 
in the input sentence, and none of the produc- 
tions combine more than one predicate variable, 
the complexity of the dependency transducing 
algorithm is O(nT). 
This algorithm can be applied to the example 
derivation tree in Section 1, 
a:fly 
I /31 :be-able-to(VP) 
I /32 :is-supposed-to(VP) 
which resembles the stacked derivation tree for 
Candito and Kahane's example 5a, "Paul claims 
Mary said Peter left." 
First, we adjoin/32 :is-supposed-to at node VP 
of/31 :be-able-to, which produces the dependency 
(is-supposed-to,0,be-able-to}. Then we adjoin 
~31:be-able-to at node VP of a:fly, which pro- 
duces the dependency (be-able-to,0,fly). The 
resulting dependencies are represented graphi- 
Cally in the dependency structure below: 
¢0 :supposed-to I 
¢\] :be-able-to(0) 
I ¢2:fly(0) 
This example is relatively straightforward, 
simply reversing the direction of adjunction de- 
pendencies as described in (Candito and Ka- 
hane, 1998a), but this algorithm can transduce 
91 
the correct isomorphic dependency structure for 
the Portuguese derivation as well, similar to the 
distributed derivation tree in Candito and Ka- 
hane's example 5b, "Paul claims Mary seems to 
adore hot dogs," (Rambow et al., 1995), where 
there is no edge corresponding to the depen- 
dency between the raising and bridge verbs: 
c~:voar 
81:~-capaz-de(VP) ~2:fi-pressuposto-que(S) 
We begin by adjoining ~1 :g-capaz-de at node 
VP of c~:voar, which produces the dependency 
(~-capaz-de, 0,voar), just as before. Then we ad- 
join p2:~-pressuposto-que at node S of c~:voar. 
This time, however, we must observe the predi- 
cate variable of the chart item for c~:voar which 
was updated in the previous adjunction, and 
now references ~-capaz-de instead of voar. Be- 
cause the transduction rule for adjunction uses 
the predicate variable of the parent instead of 
just the predicate, the dependency produced by 
the adjunetion of ~2 is (~-pressuposto-que, 0,~- 
capaz-de), yielding the graph: 
As Candito and Kahane point out, this 
derivation tree does not match the dependency 
structure of the sentence as described in Mean- 
ing Text Theory (Mel'cuk, 1988), because there 
is no edge in the derivation corresponding to 
the dependency between surprise and have-to 
(the necessity of Paul's staying is what surprises 
Mary, not his staying in itself). Using the above 
algorithm, however, we can still produce the de- 
sired dependency structure: 
¢1 :surprise 
¢2:have-to(0) Cs:Mary(1) 
I Ca:stay(0) 
I ¢4:Paul(0) 
by adjoining fl:have-to at node VP of c~2:stay 
to produce a composed item with have-to as 
its predicate variable, as well as the depen- 
dency (have-to, 0,stay/. When a2:stay substi- 
tutes at node So of c~l:surprise, the resulting 
dependency also uses the predicate variable of 
the argument, yielding (surprise, 0,have-to). 
¢0 :~-pressuposto-que 
I ¢1 :~-capaz-de(0) 
I ¢2:voar(0) 
The derivation examples above only address 
the preservation of dependencies through ad- 
junction. Let us now attempt to preserve 
both substitution and adjunction dependencies 
in transducing a sentence based on Candito and 
Kahane's example 5c, "That Paul has to stay 
surprised Mary," in order to demonstrate how 
they interact. 5 We begin with the derivation 
tree: 
al :surprise 
c~2 :stay(S0) c~4 :Mary(NPl) 
c~a:Paul(NP0) ~:have-to(VP) 
5We have replaced want to in the original example 
with have to in order to highlight the dependency struc- 
ture and set aside any translation issues related to PRO 
control. 
4 Obtaining Target Derivations 
Once a source derivation is selected from the 
parse forest, the predicate-argument dependen- 
cies can be read off from the items in the forest 
that constitute the selected derivation. The re- 
sulting dependency graph can then be mapped 
to a forest of target derivations, where each 
predicate node in the source dependency graph 
is linked to a set of possible elementary trees in 
the target grammar, each of which is instanti- 
ated with substitution or adjunction edges lead- 
ing to other linked sets in the forest. The el- 
ementary trees in the target forest are deter- 
mined by the predicate pairs in the transfer lex- 
icon, and by the elementary trees that can re- 
alize the translated targets. The substitution 
and adjunction edges in the target forest are 
determined by the argument links in the trans- 
fer lexicon, and by the substitution and adjunc- 
tion configurations that can realize the trans- 
lated targets' dependencies. 
Mapping dependencies into substitutions is 
relatively straightforward, but we have seen in 
Section 2 that different adjunction configura- 
tions (such as the raising and bridge verb ad- 
92 
junctions in sentences (1) and (2)) can corre- 
spond to the same dependency graph, so we 
should expect that some dependencies in our 
target graph may correspond to more than one 
adjunction configuration in the target deriva- 
tion tree. Since a dependency may be realized 
by adjunctions at up to n different sites, an un- 
constrained algorithm would require exponen- 
tial time to find a target derivation in the worst 
case. In order to reduce this complexity, we 
present a dynamic programming algorithm for 
constructing a target derivation forest in time 
proportional to O(n 4) which relies on a restric- 
tion that the target derivations must preserve 
the relative scope ordering of the predicates in 
the source dependency graph. 
This restriction carries the linguistic implica- 
tion that the scope ordering of adjuncts is part 
of the meaning of a sentence and should not 
be re-arranged in translation. Since we exploit 
a notion of locality similar to that of Isomor- 
phic Synchronous TAG, we should not expect 
the generative power of our definition to exceed 
the generative power of TAG, as well. 
First, we define an ordering of predicates on 
the source dependency graph corresponding to a 
depth-first traversal of the graph, originating at 
the predicate variable of the root of the source 
derivation, and visiting arguments and modi- 
fiers in order from lowest to highest scope. In 
other words, arguments and modifiers will be 
ordered from the bottom up on the elementary 
tree structure of the parent, such that the foot 
node argument of an elementary tree has the 
lowest scope among the arguments, and the first 
adjunct on the main (trunk) anchor has the low- 
est scope among the modifiers. 
Arguments, which can safely be permuted 
in translation because their number is finitely 
bounded, are traversed entirely before the par- 
ent; and modifiers, which should not be per- 
muted because they may be arbitrarily numer- 
ous, are traversed entirely after the parent. 
This enumeration will roughly correspond to 
the scoping order for the adjuncts in the source 
derivation, while preventing substituted trees 
from interrupting possible scoping configura- 
tions. We can now identify all the descendants 
of any elementary tree in a derivation because 
they will form a consecutive series in the enu- 
meration described above. It therefore provides 
a convenient way to generate a target derivation 
forest that preserves the scoping information in 
the source, by 'parsing' the scope-ordered string 
of elementary trees, using indices on this enu- 
meration instead of on a string yield. 
It is important to note that in defining this 
algorithm, we assume that all trees associated 
with a particular predicate will use the same 
argument structure as that predicate. 6 We also 
assume that the set of trees associated with a 
particular predicate may be filtered by transfer- 
ring information such as mood and voice from 
source to target predicates. 
Apart from the different use of indices, the 
algorithm we describe is exactly the reverse of 
the transducer described in Section 3, taking 
a dependency graph 79 and producing a TAG 
derivation forest containing exactly the set of 
derivation trees for which those dependencies 
hold. Here, as in a parsing algorithm, we define 
forest items as tuples of (~/¢, 'q, _1_, i,j, X) where 
a, ~, and 7 are elementary trees with node'O, ¢ 
and ¢ are predicates, X and w be predicate vari- 
ables, and T and _1_ are delimiters tbr opening 
and closing adjunction, but now let i, j, and k 
refer to the indices on the scoping enumeration 
described above, instead of on an input string. 
In order to reconcile scoping ranges for substi- 
tution, we must also define a function first(C) 
to return the leftmost (lowest) edge of the ¢'s 
range in the scope enumeration, and last(C) to 
return the rightmost (highest) edge of the ¢'s 
range in the scope enumeration. 
• For each tree 7 mapped from predicate ¢ 
at scope i, introduce (~,¢, first(C), i + 1, ¢}. 
• If (¢,arg(7,~),co) E 79, 
try substitution of c~ into 3': 
(c~¢, ROOT, T, first(co), last(co), co) 
7, ±, , ,-) 
~Although this does not hold for certain relative 
clause elementary trees with wh-extractions as substi- 
tutions sites (since the wh-site is an argument of the 
main verb of the clause instead of the foot node), Can- 
dito and Kahane (Candito and Kahane, 1998b) suggest 
an alternative analysis which can be extended to TAG 
by adjoining the relative clause into its wh-word as a 
predicative adjunct, and adjoining the wh-word into the 
parent noun phrase as a modifier, so the noun phrase is 
treated as an argument of the wh-word rather than of 
the relative clause. 
93 
• If (¢, arg(/3, FOOT), X) E 79, 
try modifier adjunction of fl into -),: 
(V~,~h_l_,i,j,x) (/3¢,ROOT, T,j,k,w) 
(V¢, ~, -l-, i, k, x) 
• If (¢, arg(/3, FOOT), X) E 79, 
try predicative adjunction of/3 into V: 
(V¢,~,_I_,i,j,x) (/3¢,ROOT, T,j,k,w) 
(V¢,~,T,i,k,w) 
• Apply productions for nonterminal projec- 
tion as in the transducer algorithm, prop- 
agating index ranges and predicative vari- 
ables up along the path from the main an- 
chor to the root. 
Since none of the productions combine more 
than three indices and one predicate variable, 
and since the indices and predicate variable may 
have no more than n distinct values, the algo- 
rithm runs in O(n 4) time. Note that one of 
the indices may be redundant with the predi- 
cate variable, so a more efficient implementation 
might be possible in dO(n3). 
We can demonstrate this algorithm by trans- 
lating the English dependency graph from Sec- 
tion 1 into a derivation tree for Portuguese. 
First, we enumerate the predicates with their 
relative scoping positions: 
\[3\] ¢0:is-supposed-to 
I \[2\] ¢l:be-able-to 
I \[i\] ¢2:fly 
Then we construct a derivation forest based 
on the translated elementary trees a:voar,/31 :d- 
capaz-de, and /32 :d-pressuposto-que. Beginning 
at the bottom, we assign to these constituents 
the relative scoping ranges of 1-2, 2-3, and 3-$, 
respectively, where $ is a terminal symbol. 
There is also a dependency from is-supposed- 
to to be-able-to allowing us to adjoin /32:d- 
pressuposto-que to /31:d-capaz-de to make it 
cover the range from 2 to $, but there would 
be no S node to host its adjunction, so this pos- 
sibility can not be added to the forest. We can, 
however, adjoin/32:d-pressuposto-que to the in- 
stance of a:voar extending to/31 :d-capaz-de that 
covers the range from 1 to 3, resulting in a com- 
plete analysis of the entire scope from 1 to $, 
(from (~:voar to/32:pressuposto) rooted on voar: 
(O~voar, l,2,..) (/3capaz, 2, 3, ..) (/3press, 3, $, ..) 
<O~voar ' 1, 3, capaz) 
<avoar, 1, $, press} 
which matches the distributed derivation tree 
where both auxiliary trees adjoin to roar. 
\[1-$\]a:voar 
\[2-3\]/31:6-capaz-de(VP) \[3-$\]~2:6-pressup.-que(S) 
Let us compare this to a translation using the 
same dependency structure, but different words: 
\[3\] ¢0 :is-going-to 
I \[2\] ¢l:be-able-to 
I \[1\] ¢2:fly 
Once again we select trees in the target lan- 
guage, and enumerate them with scoping ranges 
in a pre-order traversal, but this time the con- 
struction at scope position 3 must be translated 
as a raising verb (vai) instead of as a bridge con- 
struction (d-pressuposto-que): 
(avoar, l,2,..> (/3capaz,2,3,..> (/3vai,3,$,..> 
(avoar, l,2,..) (/3capaz,2,3,..> (/3press, 3,$,..> 
Since there is a dependency from be-able-to to 
fly, we can adjoin/31:d-capaz-de to a:voar such 
that it covers the range of scopes from 1 to 3 
(from roar to d-capaz-de), so we add this possi- 
bility to the forest. 
Although we can still adjoin/31 :ser-capaz-de at 
the VP node of a:voar, we will have nowhere 
to adjoin /32:vai, since the VP node of a:voar 
is now occupied, and only one predicative tree 
may adjoin at any node. 7 
(avoar, 1, 2,..) (t3capaz, 2, 3, ..) (/3vai, 3, $, ..) 
(avoar, 1, 3, capaz> 
(avoar , l, 2, ..) (/3capaz, 2, 3, -.) (/3;ress, 3,$,..) 
(avoar, 1, 3, capaz) 
7See (Schabes and Shieber, 1994) for the motivations 
of this restriction. 
94 
Fortunately, we can also realize the depen- 
dency between vai and ser-capaz-de by adjoin- 
ing/32 :vai at the VP. 
<avo r, l, 2, ..) <13capaz, 2, 3, ..) (/3va , 3, $, ..) < capaz, 2, $, vai) 
The new instance spanning from 2 to $ (from 
~1 :capaz to/32 :vai) can then be adjoined at the 
VP node of roar, to complete the derivation. 
( avoar , 1, 2, ..) (flcapaz, 2, 3,..) (~vai, 3, $,..) 
(~cap~z, 2, $, vai) 
(Olvoar , 1, $, vai) 
This corresponds to the stacked derivation, 
with p2:vai adjoined to t31:ser-capaz-de and 
1~1 :ser-capaz-de adjoined to a:voar: 
\[1-$\] a:voar 
I \[2-$\] ~1 :ser-capaz-de(VP) 
I \[3-$\] ~2 :vai(VP) 
5 Conclusion 
We have presented two algorithms - one for in- 
terpreting a derivation forest as a semantic de- 
pendency graph, and the other for realizing a 
semantic dependency graph as a derivation for- 
est - that make use of semantic dependencies as 
adapted from the notion of predicate-argument 
attachment in (Joshi and Vijay-Shanker, 1999), 
and we have described how these algorithms can 
be run together in a synchronous TAG trans- 
lation system, in CO(n 7) time, using transfer 
rules predicated on isomorphic or locally non- 
isomorphic dependency graphs rather than iso- 
morphic or locally non-isomorphic derivation 
trees. We have also demonstrated how such 
a system would be necessary in translating a 
real-world example that is isomorphic on de- 
pendency graphs but globally non-isomorphic 
on derivation trees. This system is currently 
being implemented as part of the Xtag project 
at the University of Pennsylvania, and as nat- 
ural language interface in the Human Modeling 
and Simulation project, also at Penn. 

References 
Anne Abeill6, Yves Schabes, and Aravind K. Joshi. 
1990. Using lexicalized tree adjoining grammars 
for machine translation. In Proceedings of the 
13th International Conference on Coraputatio'nal 
Linguistics (COLING '90), Helsinki, Finland, Au- 
gust. 
Marie-Helene Candito and Sylvain Kahane. 1998a. 
Can the TAG derivation tree represent a semantic 
graph? In Proceedings of the TAG+4 Workshop, 
University of Pennsylvania, August. 
Marie-Helene Candito and Sylvain Kahane. 1998b. 
Defining DTG derivations to get semantic graphs. 
In Proceedings of the TAG+~ Workshop, Univer- 
sity of Pennsylvania, August. 
Aravind Joshi and K. Vijay-Shanker. 1999. Com- 
positional Semantics with Lexicalized Tree- 
Adjoining Grammar (LTAG): How Much Under- 
specification is Necessary? In Proceedings of the 
2nd International Workshop on Computational 
Semantics. 
Aravind K. Joshi. 1985. How much context sensitiv- 
ity is necessary for characterizing structural de- 
scriptions: Tree adjoining grammars. In L. Kart- 
tunen D. Dowty and A. Zwicky, editors, Natural 
language parsing: Psychological, computational 
and theoretical perspectives, pages 206-250. Cam- 
bridge University Press, Cambridge, U.K. 
Anthony S. Kroch. 1989. Asymmetries in long dis- 
tance extraction in a TAG grammar. In M. Baltin 
and A. Kroch, editors, Alternative Conceptions 
of Phrase Structure, pages 66-98. University of 
Chicago Press. 
Igor Mel'cuk. 1988. Dependency syntax: theory and 
practice . State University of NY Press, Albany. 
Owen Rainbow and Giorgio Satta. 1996. Syn- 
chronous Models of Language. In Proceedings of 
the 34th Annual Meeting of the Association for 
Computational Linguistics (A CL '96). 
Owen Rambow, David Weir, and K. Vijay-Shanker. 
1995. D-tree grammars. In Proceedings of the 
33rd Annual Meeting of the Association for Com- 
putational Linguistics (A CL '95). 
Yves Schabes and Stuart M. Shieber. 1994. An al- 
ternative conception of tree-adjoining derivation. 
Computational Linguistics, 20(1):91-124. 
William Schuler. 1998. Expoiting semantic depen- 
dencies in parsing. Proceedings of the TAG+4 
Workshop. 
Stuart M. Shieber and Yves Schabes. 1990. Syn- 
chronous tree adjoining grammars. In Proceedings 
of the 13th International Conference on Compu- 
tational Linguistics (COLING '90), Helsinki, Fin- 
land, August. 
Stuart M. Shieber. 1994. Restricting the weak- 
generative capability of synchronous tree adjoin- 
ing grammars. Computational Intelligence, 10(4). 
K. Vijay-Shanker and D.J. Weir. 1993. The use of 
shared forests in tree adjoining grammar parsing. 
In Proceedings of EA CL '93, pages 384-393. 
