\[ Type-Driven Semantic Interpretation of f-Structures \] 
¿.~,w),(njO) 
Jiirgen Wedekind 
Institute for Natural Language Processing 
University of Stuttgart 
Azenbergstr. 12 
D-7000 Stuttgart 1, FRG 
juergen@ims.uni-stuttgart.de 
Ronald M. Kaplan 
Xerox Palo Alto Research Center 
3333 Coyote Hill Road 
Palo Alto, California 94304 USA 
Kaplan.Parc@Xerox.Com 
Abstract 
The formal architecture of Lexical Func- 
tional Grammar offers a particular formal 
device, the structural correspondence, for 
modularizing the mapping between the sur- 
face forms of a language and representa- 
tions of their underlying meanings. This 
approach works well when the structural 
discrepancies between form and meaning 
representations are finitely bounded, but 
there are some phenomena in natural lan- 
guage, e.g. adverbs in English, where this 
restriction does not hold. In this paper, we 
describe rule-based type-driven interpreta- 
tion algorithms which cover cases of such 
a structural misalignment by exploiting a 
new descriptive device, the "restriction op- 
erator". The algorithms are set up in such 
a way that recursive rules can be derived 
for the interpretation of adjunct sets within 
a codescripiion approach (see \[Kaplan and 
Wedekind, 1993\] for details). 
1 Introduction 
In \[Kaplan and Bresnan, 1982\] Lexical Functional 
Grammar (LFG) was introduced as a grammatical 
formalism that assigns to a sentence entities of two 
different levels of representation: a c-structure rep- 
resenting information on the structure of the phrases 
of a sentence and an f-structure which represents its 
underlying predicate-argument structure. The struc- 
tures are set in correspondence by a function from 
the c-structure nodes (constituents) into the sub- 
structures of the f-structure. The f-structure is iden- 
tified with the smallest structure that satisfies the 
f-description, a description of the f-structure which 
is built up by instantiation of the annotations of the 
context-free rules and projected off the c-structure 
by the correspondence mapping. 
This architecture was then extended by Kaplan 
\[1987\] and Halvorsen \[1987\] to structures represent- 
ing information on other levels of linguistic repre- 
sentation. These structures (called projections) are 
codescribed by the annotations of the context-free 
grammar and set in correspondence by additional 
projectors. Furthermore, Kaplan et ai. \[1989\] applied 
the general correspondence architecture to the prob- 
lem of translation by projecting from the f-structure 
of a sentence of a given source language an addi- 
tional f-structure of its translation into some target 
language. 
Within the domain of semantic interpretation, 
which is the topic here, the semantic structures are 
the range of the a-projector which maps substruc- 
tures of the f-structure into corresponding substruc- 
tures of the semantic structure. In figure 1, the 
S ........ rPaED 'arrive(SUB J)' 1 
P VP ":/ su~Ja, \[PRED Jonn J N , --': t..- , \]J/ 
i-.. i /.j k 
N " .... Z:~ "/'~ PP~L~. arrive\] I "-. .J*'" / ~.. / 
John ""arrived L.~,.G1 3ohn J 
Figure 1 
Structural correspondences between c-, f- and 
a-structure. 
semantic structure ((r-structure) and the structural 
correspondence between f- and a-structure for the 
sentence John arrived are codescribed by additional 
404 
annotations of the lexical entry for arrived in (1). 
(1) arrived: V, (T PrtED)= "arrive(SUDJ)' 
(a T REL) ---- arrive 
(a T AaQ1) = a(T sunJ) 
Within the domain of translation, Wedekind \[1988\], 
and Sadler and Thompson \[1991\] recognized some 
problems of the correspondence approach which con- 
cern data of head.switching. These difficulties also 
arise in the domain of semantic interpretation. In 
the latter domain we find constructions where the 
syntactic head (the predicate) does not correspond 
to the semantic head as, e.g., in adverbially-modified 
sentences like (2) 
(2) John arrived late 
whose f- and a-structure are given in figure 2. In 
f: \]PRED 'arrive(SUB J)' P.EL lS ., \[P D 'john'\] ARG1 ARG\] 
Figure 2 
Head-switching between fJand a-structure. 
arr'wl\] 
joh. JJ 
this diagram, the semantic-structure corresponding 
to the entire f-structure has the adverb "late" as its 
top-level relation, even though this does not corre- 
spond to the syntactic (f-structure) head "arrive". 
Intuitively, the semantic argument (ArtG 1) of the ad- 
verb corresponds to the information coded in the par- 
tim f-structure (3), which comprises only the infor- 
mation concerning the subject and the predicate of 
the sentence. 
(3) F PP~D 'arrive(suBJ)'\] 
LS ., \[PRED 'john'lJ 
The formal difficulty is that this is not an isolated 
unit of the f-structure and hence cannot be in the 
domain of a. However, the f-structure description 
language can be extended by introducing a restric- 
tion operator which allows explicit reference to such 
smaller f-structures. The restriction operator "\" 
which is defined in (4) below 1 allows us then to refer 
to the partial structure (3) by the term f\(ADJ a). 
(4) The restriction operator is defined for an f- 
structure f and an attribute A by: 
(i) f\A = f\]Dom(f) - {A} if the value of(f A) is 
a structure, and 
(it) if g e (f A) (i.e. if (f A) is set-valued) by 
f\(A g) ff\A if (f A) -- {g} -- 0 
= Lf\A U {(A,(f A) -- {g})} else. 
1Cf. \[Kaplan and Wedekind, 1993\] for more details. 
On the other hand, it becomes clear by examples 
with more than one adjunct that in addition a new 
source for recursion is needed, since it must in prin- 
ciple be possible to construct a multiple nesting for 
adjunct sets whose size is not bounded by any fixed 
finite upper bound. 2 
In order to identify this additional recursive de- 
vice and to test our extended description language 
for adequacy, we picked out Montague semantics as 
a well-known semantic theory and tried to specify the 
syntax-semantics interface by a rule-based semantic 
interpretation mechanism. Our goal is to derive the 
semantic representation by analyzing the f-structure 
recursively. We assume an interpretation mechanism 
that operates on f-structures (possibly extended by 
information on the linear precedence of the predi- 
cates) and can be stated by very general composi- 
tionality principles without relying on any kind of 
transformations. This is because an f-structure of 
a sentence represents its deep structure in terms of 
predicate-argument relations where all information 
relevant for the interpretation is locally available. 
Furthermore, we want to ensure the "completeness" 
of the interpretation and to specify conditions which 
allow us to control the "conservativity" of the exten- 
sion (for those who require that a theory of gram- 
mar such as LFG be strong enough to ensure the 
(semantic) well-formedness of the strings accepted 
by a particular grammar). On the other hand, we 
want the semantic structure to be accessible from 
the f-structure by an explicit interpretation function 
(a-projector) in order to be able to formulate con- 
straints, e.g. binding and scoping principles, which 
constrain the interpretation of the f-structures. 
In this paper, we give three different type-driven 
interpretation mechanisms which fulfill the require- 
ments given above. The first one is a rather simple 
top-down algorithm that can be described by our ex- 
tended description language but cannot be used for 
all type systems. The second algorithm is a more 
powerful bottom-up algorithm which can be used for 
all type systems but not formulated in our descrip- 
tion language. The third one, finally, is a top-down 
simulation of the second algorithm which is again de- 
scribable in our description language. The fact that 
the third algorithm can be described by our extended 
description language seems to confirm the adequacy 
of our extension by the restriction operator. Further- 
more, this investigation indicates that an additional 
description-by-analysis mechanism is needed within 
a codescription approach in order to handle cases 
2This situation, where the recursion given by the 
context-free rule system turns out not to be the adequate 
or at least desirable carrier for specific (recursive) descrip- 
tion purposes, is not unusual. Functional uncertainty was 
e.g. introduced as a new recursive device operating on f- 
structures, since unbounded dependencies could be more 
adequately handled by this new mechanism than by ex- 
ploiting the recursive phrase structure rule system alone. 
405 
where the interpretation recursion is completely in- 
dependent of the recursion given by the context-free 
grammar (cf. \[Kaplan and Wedekind, 1993\]). 
2 A Simple Top-down Type-driven 
Interpretation Algorithm 
In order to sketch how we can achieve a decompo- 
sition of an f-structure which is sufficient for its in- 
terpretation, we first introduce a simple top-down 
interpretation procedure which is restricted to cer- 
tain special type systems. For the interpretation 
we generally assume from now on that types are as- 
signed to all grammatical function values and seman- 
tically relevant atomic-valued features by a type as- 
signment TY. Aside from the fact that grammatical 
functions and values and not c-structure constituents 
are typed, this assignment is similar to the one used 
in Montague grammar. The structure in figure 3 e.g. 
is an oversimplified typed f-structure 3 of the sentence 
(5) John arrived late today. 
~DJ 
I" 
PILED 
SUBJ 
L., 
/::rp o r l tell } 
LO,O LO.O jj 
\[PILED \['today'\]\] 
L(,,,) L<'") Jj 
'arrive'\] 
(,,.~) J 
Figure 3 
The typed f-structure of sentence (5). 
The typing of the f-structures can e.g. be established 
by additional type-assigning annotations within a 
grammar. Examples of such augmented rules and 
lexical entries are given in (6). 
(6) S ~ NP VP (T s~) =~ T=~ 
TY(I)=e TY(T)=t 
arrived: V, (1" PILED) ---~ 'arrive' 
"TY(T PREY) = (~, t> 
It is of course possible to think of more sophisti- 
cated type inheritance mechanisms for the specifi- 
cation of the f-structure typing. The investigation 
of such mechanisms, however, is beyond our present 
concerns. 
The restrictedness of the algorithm results from 
the fact that it operates under the assumption that 
we can recursively decompose each f-structure f into 
3We drop the subcategorization frames in the 
following. 
a substructure or set element which corresponds to 
a one-place main functor and the rest structure of f 
which is interpreted as the argument of that functor. 
Although this restriction seems to be rather strong, 
this algorithm gives the right hierarchical semantic 
structures for the problematic flat f-structures con- 
taining sentence modifiers. And if we assume the 
usual type-raising for the subcategorized functions, 
it also describes all possible structural ambiguities 
for predicate modifiers, quantifiers, etc. 4 In detail, 
the algorithm works as follows. 
Proceeding from an initial mapping of a given f- 
structure f into an empty semantic structure the in- 
terpretation works top-down according to the follow- 
ing two principles: 
If trg is defined and h is a substructure (h = (g A)) 
or an element of a set-value of g (h E (g A)) and 
(A1) TY(g) - r and TY(h) = {r', r) then 
(i) (g A) = h "-+ (fig FU) "- trh A 
(fig ARG) ---~ a(g\A) A TY(g\A) = r', 
(ii) h e (g A) ---* (#g FU) -" ah A 
(ag ARG) = a(g\(A h))A TY(g\(A h )) = v', 
(A2) TY(g) = v A TY(h) = r ---* ~9 = ah. 
The principle (A1) allows us to select a substructure 
or an element of a set value of type /v ~, r) from a 
structure g of type r, which is already mapped into 
the semantic representation, as a funetor and inter- 
pret the rest of g as its argument which becomes 
then of type r'. 5 If we apply principle (Alii) to 
the structure in figure 3 and choose b as the rune- 
for we end up with the constellation in figure 4. 
For an interpreted structure g containing an imme- 
diate substructure or a set element h, principle (A2) 
drops the interpretation downwards if g and h are 
of the same type. This principle can then be ap- 
plied e.g. to b of figure 4 and achieves the mapping 
in figure 5. Figure 6 gives a complete type-driven 
derivation of the functor-argument structure of (5) 
with wide scope of 'late'. One gets the other reading 
by first selecting b as described above. 
Note that the meanings are not constructed by our 
procedure. The complete semantic representation re- 
sults then from the insertion of the meanings of the 
basic expressions which are assumed to be specified 
in the lexicon via equations like the following: 
late: ADV, (T BRED) = 'late' 
4 For further illustration of the algorithms we give ex- 
amples involving transitive verbs in the appendix. 
5Note that a distinct re-interpretation of an already 
interpreted structure always fails, since predicates and 
predicate projections do not unify in LFG. Without this 
assumption, one would have to add to the principles the 
condition that g has no interpreted part. 
406 
f: 
i a: \[PRED ,*,VJ { Lo,') 
/b: \[PRED 
~, LO.') 
PRED \['~ve'l t(',') J 
SUBJ \[PRED 
.# 
f\ (ADJ b): 
\['l~te'\]\] \] "" J\] 
\['today'11/ to.,~ J j) 
{°:\[~.~o r',.,ol1 LO,') tO,t) jj }' 
PILED \['arrive'\] L(=, ,) J 
= \[ro 
cr 
Figure 4 
The result of applying principle (Alii) to b E (f ADJ) 
in figure 3. 
ADJ 
I: 
PLIED 
SUBJ 
t \ 
f\ (ADJ b) 
{.rP~D r,l~t~,l\] ~ =L,,,, L,,,, Jj~~ 
, \['today'\]l I . -" Lo,,> t,.o jjj 
,. |FU 
\['=rive'\] I L~n% 
L(',') J I / 
Figure 5 
The result of applying principle (A2) to b in figure 4. 
The result is then the following structure 
L AP,-<~ j l J 
and the meaning of the sentence can be calculated 
bottom-up by )t-conversion in the usual way. 
"FU ~p( L(p ) ) 
FU ~q(T(q)) 
FU x(A(x)) ARG ARG ARG 
LT(A(j)) LA(J) 
L(T(A(j))) 
So, we end up with the expression L(T(A(j))) which 
corresponds to the wide scope reading of 'late'. 
j,': 
~~ late \[,° 
L: 
= fa:f,~ 
hate'\]\] } ) L(',') tO.') JJ 
ADJ Ib: \[pREo 
\['today'1\] ~' L(',') t(',') JJ 
PRED \['=.ve'\] L(",') J 
• ' 
f\ (ADJ a)" 
I i~L,P,.,~ v L,=~ 
\['=rive'\] PRED L(',=) J 
f\(AD3 a)\(ADJ b): 
;UBJ 
today 
\['=.ve'\] ~ I 
¢'"~ J I 
\ 
Figure 6 
A complete derivation of one reading of (5). 
i~-jjj 
3 A Bottom-up Type-driven 
Interpretation Algorithm 
In the following we sketch a more powerful mecha- 
nism which can also handle cases where the functor 
is not given by a substructure (f A) or a set ele- 
ment g E (f A) hut by a partial structure g sub- 
sumed by f (g C f) as e.g. in the typed structure 
for sentence (7) in figure 7. Here the part of the f- 
structure that comprises the modifiers and the predi- 
cate has to he interpreted as the main functor (either 
407 
Stimes( twiee( knock ) ) or twiee( Stiraes( kno& ) ) ). 
(7) John knocked twice three times. 
I: 
ADJ 
SUBJ 
'BED 
'a:bRED \['3times' 11 } 
L(<.,o,<.,o) Lt(.,o.<.,m JJ 
b: \[PRED \['twice' 1\] 
, Ltt.,O,<',m L.,,,o,~.,,>>JJ 
'knock'\] 1",0 J 
Figure 7 
The typed f-structure of sentence (7). 
Let "\[" be a new operator which is defined for a sub- 
structure (f A) off by f\[A = f\] {A} and for a set ele- 
ment g G (f A) by f\[(A g} = {(A, {g})}. The value is 
simply the f-structure subsumed by f which has only 
attribute A with its value in f or with the singleton 
set-value g. For every attribute or attribute-element 
pair x, f\z and fix are in fact complementary with 
respect to f, that is, f\x \[7 fix = 0. 
Proceeding from the interpretations of the basic 
expressions introduced by the lexical entries the al- 
gorithm works bottom-up according to the following 
principles: 
(B1) If trh and irk are defined, h E g, k E_ g and 
h N k = 0 and TY(h) = {r, r'} and 
TY(k) = r, then 
= u k) FU) ^ = U k) ARG) ^ 
TY(h I.J k) = r'. 
(B2) If trh is defined and TY(h) = r, then 
(i) (g A) = h ~ TY(giA ) = 7"Aah = a(glA), 
and 
(ii) h G (g A) ~ TY(g\[(A h)) = r A 
ah = cr(gl(A h)). 
Principle (B2) pushes the interpretation from an in- 
terpreted structure h one level upwards to the partial 
structure of the given structure which contains only h 
as an attribute- or set-value and assigns to that par- 
tial structure the type of h. Note that principle (B2) 
can only be applied if glA resp. gl(A h) has no type 
assignment or is of the same type as h (otherwise the 
type assignment would not be a function). 
If a structure g contains two disjoint partial struc- 
tures h and k, one of them being an appropriate 
argument for the other, then the structures are in- 
terpreted according to principle (B1) as the functor 
resp. argument of the interpretation of their unifi- 
cation. This is then assigned the value-type of the 
functor. Figure 8 shows how the semantic represen- 
tation of one reading of sentence (7) is constructed. 
We represent here attribute-value paths in DAG form 
| 
/ IT" / /Z '""'" 
Figure 8 The bottom-up construction of one reading of (7). 
and depict the decomposition of the f-structure as a 
graph where each subtree dominated by a branching 
node represents the partial f-structure which com- 
prises the attribute-value paths contained in that 
subtree. The construction starts with the mapping of 
the terminal nodes provided by the lexical entries of 
the basic expressions. Each mapping of a structure 
dominated by a non-branching non-terminal node 
results from an application of principle (B2). The 
interpretation of a partial substructure (a structure 
dominated by a branching node) is constructed by 
principle (B1). 
4 A Top-down Simulation of the 
Bottom-up Interpretation 
Algorithm 
The restrictedness of the simple top-down algorithm 
results from the fact that the main functor was al- 
ways assumed to take exactly one argument which 
is represented by the semantics of the rest of the 
f-structure. The algorithm fails in cases where the 
type of the substructure representing the main func- 
tor indicates that more than one argument is needed 
by the main functor in order to yield a meaning of the 
type of the entire f-structure. If we choose e.g. the 
'3times' modifier in the structure of figure 7 as the 
main functor (having widest scope), then we need a 
first argument of type (e,t) and a second argument 
of type e to get a meaning of type t. So, the rest 
of the structure corresponds in the general case to a 
list or set of arguments. 
In order to overcome this difficulty, we assign to 
408 
the rest structure now a separate semantic structure. 
This structure is a set that contains typed variables 
for all those arguments which are still needed to sat- 
urate previously processed (complex) functors. If we 
start with the '3times' modifier this set contains the 
typed variables ae and a(e,t). In detail the algorithm 
works as follows• 
If TY(f) = r the algorithm starts from the initial 
assignment ~rf = fr and proceeds top-down accord- 
ing to the following principles: 
If ag is defined and h is a substructure (h = (9 A)) 
or an element of a set-value of g (h E (g A)), 
YY(h) = (rn, ('rn-1...(T1, 7")..)) and 
(C1) ag = kr and n > O, or there is a kr E ag and 
n > O, then o'h -" (kr FU n) = h(r,,(r,_,...(rt,r)..)), 
(kr FU i-1 ARG) = h i (for each i : 1, n) 
and 
(i) if (g A) ---- h then 
\[{h~,..,h'~} if kr =~g o'(g \A) = t(og -- {k,}) LI 
{hr,,.. ,1 hr,~ }n else,6 
(ii) ifh G (g A) then o'(g\(A h)) is determined as 
in case (i), 
(C2) ag = k~ and n = O, then ~g = ah. 
In contrast to the simple top-down algorithm, each 
application of (C1) creates a new semantic structure 
which includes typed variables for all missing argu- 
ments. The new structure is linked to structures pre- 
viously constructed either by explicit reentrancies or 
because they share common substructures. (The lat- 
ter is enforced, since all those arguments (typed vari- 
ables) which remain to be found after selecting kr are 
passed on to the semantic representation of the next 
restriction by (Cli,ii).) Reentrancies are used to link 
the (new) arguments to their right positions which 
are encoded in a functor-argument matrix in ~rg by 
applying (C1). Figure 9 gives three steps of a deriva- 
tion of one reading of (7). (We omit in the example 
the upper indices of the typed variables provided by 
(C1), since no funetor needs more than one argument 
of the same type.) 
5 Completeness, Conservativity, 
Constraints and Compositionality 
Since the meaning of a sentence with an f-structure 
f is given by the formula described by the seman- 
tic representation or f, the bottom-up construction 
is successful if we have constructed a value for ~rf. 
Within the top-down approaches the meaning of each 
basic expression represented in the f-structure has 
to be connected with the root or f, otherwise the se- 
mantic representation would not be a description of 
a well-formed formula. 
eI.e, if k~ E ag. 
/: 
~'DJ I :i \[P(~i(¢'Q) dl i(e'l~,~~:)))) \]\]I I 1 
SUBJ ,.\[PI~t.ED \]L\[~ Ohn'\] / 
PRED i" \['knock'\] 
• \[(.,0 J 
~ D ~b(e't): \[ae: 
IPRED /:\['knock'\] 
L t(-.,) J 
Figure 9 
Some steps of the interpretation of (7). 
} 
In LFG, we can ensure that all syntactically well- 
formed utterances are also semantically well-formed 
by mechanisms which are already part of the theory. 
By the completeness and coherence conditions it can 
first be guaranteed that the different kinds of nuclei 
(consisting of a predicate and the functions it sub- 
categorizes for) will get an interpretation of the right 
type. Since all free grammatical functions (ADJ) are 
homogeneous functors (argument and value are of 
the same type) and it is clear from the c-structure 
rules which type of argument they modify (a modifier 
on S-level is either a sentence or predicate modifier, 
409 
etc.), f-structures with free functions can also be en- 
sured to be interpreted. 
On the other hand particular readings can be ex- 
cluded by global binding and/or scoping principles, 
similar to the ones formulated in \[Dalrymple et al., 
1990\]. These principles constrain the interpretation 
of the f-structures and their parts if special con- 
ditions are satisfied. By combining outside-in and 
inside-out functional uncertainty we can express by 
the following constraint e.g. that under some condi- 
tions E the substructure (T A) of an f-structure has 
wide scope over (T B): 
Z -"* ((FU 0"(T A)) ARG + FU) "-¢ o-(T B). 
Due to the interpretation function (~r) between a 
typed f-structure and its semantic representation it 
is also possible to formulate a compositionality prin- 
ciple very similar to the classical one. The classi- 
cal compositionality principle (Frege principle) says 
roughly that the meaning of an expression is a func- 
tion of the meaning of its components and their mode 
of combination and is normally specified in terms 
of c-structure categories and their immediate con- 
stituents. As is well-known, the attractiveness of this 
principle gets lost to some degree if we have to handle 
phenomena which can only be described by assuming 
transformations on the constituent structures. 
In LFG, the f-structures describe explicitly the 
underlying predicate-argument structures of well- 
formed expressions, and the components of an ex- 
pression are taken to be the sets of string elements 
that are mapped via ¢ (the structural correspon- 
dence between c- and f-structure) to the units of 
its type-driven decomposed f-structure. On this 
view, the meaning of an expression remains a func- 
tion of the meaning of its components. Thus, 
the reading of sentence (5) given in figure 6, e.g., 
is composed of the meanings of the components 
{(1, John), (2, arrived), (4, today)} and {(3,1ate)} as- 
sociated with f \ (ADJ a) and a by ¢, respectively. 
Their mode of combination (determined by the type 
assignment) is encoded in the functor-argument ma- 
trix as function-application of aa to a(f \ (ADJ a)) 
(i.e. the meaning is o'a(a(f \ (ADJ a)))). Ambigui- 
ties result then from the indeterminism of the type- 
driven decomposition of the f-structure of a sentence. 
Thus, we can state for LFG a compositionality prin- 
ciple without assuming any kind of transformations, 
since all information relevant for the interpretation 
is locally available (cf. e.g. \[Bresnan et al., 1982\]). 
6 Conclusion 
In this paper and in \[Kaplan and Wedekind, 1993\] 
we introduced a new formal device, the "restriction 
operator", into the language of functional descrip- 
tions. This operator provides a natural account of 
the misalignment between f-structures and semantic 
structures in cases where semantic units correspond 
intuitively to subsets of functional information. We 
tested this new descriptive device by formulating uni- 
versal interpretation principles that derive represen- 
tations of a Montagovian semantics by recursively 
analyzing typed f-structures. We outlined three in- 
terpretation algorithms, all of which depend on a 
description-by-analysis recursion that is independent 
of the recursion of the phrase-structure grammar. 
The first algorithm is formulated in terms of the 
f-designators provided by our extended description 
language, but is restricted to special type systems. 
In order to cover arbitrary type systems, we intro- 
duced a more powerful bottom-up algorithm which 
we were then able to simulate in a top-down fashion 
using again only the f-designators of our extended 
description language. This provides some support 
for the adequacy of our extended description lan- 
guage and reinforces the results reported by Kaplan 
and Wedekind \[1993\]. They combined the restric- 
tion operator with description-by-analysis rules for 
the interpretation of sentential and VP-adjuncts in a 
codescription approach which, although not explic- 
itly driven by types, is patterned after the top-down 
algorithms presented here. 
Appendix 
Because of the particularly interesting cases of mis- 
alignment that they present, we concentrated in the 
main part of this paper almost exclusively on the 
interpretation of modifiers. Also, modifiers are in- 
volved in the head-switching translation problems 
discussed by Kaplan and Wedekind \[1993\], and the 
algorithms proposed here underlie the description- 
by-analysis approach that we developed in that pa- 
per. As suggested by the reviewers, we briefly sketch 
in this appendix how our approach extends to exam- 
ples involving transitive verbs. Although their inter- 
pretation depends crucially on the type system and 
the actual meaning assigned to transitive verbs in 
the lexicon, we assume here a type system which is 
well-known from PTQ. This type system allows us 
to cover quantifier scope ambiguities as in (8) 
(8) Every man loves a woman. 
If we apply the simple top-down algorithm to the 
typed f-structure of (8) we get both readings due to 
an indeterminism in picking out the functors. Fig- 
ure 10 shows some steps of a derivation where the 
universal quantifier has wide scope. (The other read- 
ing would be the result if (f OBJ) were selected first.) 
Although the given type system would, of course, al- 
ways yield SUBJ/OBJ scope ambiguities, specific read- 
ings can be excluded by a system of interacting scop- 
ing constraints, since the semantic structure is ac- 
cessible via the a-projector7 The functional uncer- 
7In the few cases where the the scope is determined 
by the transitive verb itself, e.g. some passive forms in 
English, the appropriate reading can be enforced directly 
by using h-expressions which refer explicitly to the mean- 
410 
L(~, 0 lJ L(,~,,) 
I: 
f\ SUB J: 
' pevery' 
;UBJ \['man'\] I I PRED \[(e,,) \] j \] 
, .((,~.0,0 
;PRED 'love' \] (((~,,),,),(e,,)) J \[ 
\]l SPEC \[11c,¢1,11.,,),0 ) 
)BJ \[PRED \['woman'\] | 
L,,-.,,.,, t,..,, j 
PRED \['love' l \[(((~.0.0,(~,0) J 
L((=,O, ((~,,),,)) J \[ OBJ \['woman'\] / 
PRED \[(e,0 J J 
(,,,,) L ((°'')'') 
Figure 10 
Some steps in the derivation of one reading of (8). 
\[Kaplan, 1987\] Kaplan, R. Three Seductions of 
Computational Psycholinguistics. In P. Whitelock 
et al., eds., Linguistic Theory and Computer Ap- 
plications. London: Academic Press, 1987. 
\[Kaplan and Bresnan, 1982\] Kaplan, R., and J. 
Bresnan. Lexical-Functional Grammar: A For- 
mal System for Grammatical Representation. In 
J. Bresnan, ed., The Mental Representation of 
Grammatical Relations. Cambridge, Mass.: The 
MIT Press, 1982. 
\[Kaplan et al., 1989\] Kaplan, R., K. Netter, J. 
Wedekind, and A. Zaenen. Translation by Struc- 
tural Correspondences. In Proceedings of the Sth 
Conference of the European Chapter of the Associ- 
ation for Computational Linguistics. Manchester, 
1989. 
\[Kaplan and Wedekind, 1993\] Kaplan, R., and J. 
Wedekind. Restriction and Correspondence-based 
Translation. In Proceedings of the 6th Conference 
of the European Chapter of the Association for 
Computational Linguistics. Utrecht, 1993. 
\[Sadler and Thompson, 1991\] Sadler, L., and H. 
Thompson. Structural Non-Correspondence in 
Translation. In Proceedings of the 5th Confer- 
ence of the European Chapter of the Association 
for Computational Linguistics. Berlin, 1991. 
\[Wedekind, 1988\] Wedekind, J. Transfer by Projec- 
tion. Ms., University of Stuttgart, 1988. 
tainty constraint 
((FU ~,(T susJ)) ARC+ FU) =~ "(l On J) 
which can, appropriately annotated, be used in the 
grammar to enforce directly wide scope of the subject 
is just a simple example of the form of a constraint 
contained in such a system. 
References 
\[Bresnan et al., 1982\] Bresnan, J., R. Kaplan, S. Pe- 
ters, and A. Zaenen. Cross-serial Dependencies in 
Dutch. Linguistic Inquiry 13,613-635, 1982. 
\[Dalrymple et al., 1990\] Dalrymple, M., J. Maxwell, 
and A. Zaenen. Modeling Syntactic Constraints 
on Anaphoric Binding. In Proceedings of the 13th 
International Conference on Computational Lin- 
guistics. Helsinki, 1990. 
\[Halvorsen, 1987\] Halvorsen, P.-K. Situation Seman- 
tics and Semantic Interpretation in Constraint- 
based Grammars. CSLI Report No. 87-101. Stan- 
ford University, 1987. 
ings of the grammatical functions. (If we would e.g. use 
Ax(ona'(love'(r))) as the a-value for 'love', we would al- 
ways get wide scope of the subject.) 
411 
