CopFliSag03.pdf

CopFliSag03.pdf
Minimal Recursion Semantics
An Introduction
Ann Copestake
Cambridge University
Dan Flickinger
Stanford University
Ivan A. Sag
Carl Pollard
Stanford University Ohio State University
Abstract
Minimal recursion semantics (MRS) is a framework for computational semantics that is
suitable for parsing and generation and that can be implemented in typed feature structure
formalisms. We discuss why, in general, a semantic representation with minimal structure
is desirable and illustrate how a descriptively adequate representation with a nonrecursive
structure may be achieved. MRS enables a simple formulation of the grammatical constraints
on lexical and phrasal semantics, including the principles of semantic composition. We have
integrated MRS with a broad-coverage HPSG grammar.
1
Introduction
Our aim in this paper is to describe an approach to semantic representation for large-scale
linguistically-motivated computational grammars of natural language. We believe such grammars should support both parsing and generation, and should be useful for multiple applications, including natural language interfaces of various sorts and machine translation. Our
main general criteria for computational semantics are:
Expressive Adequacy The framework must allow linguistic meanings to be expressed correctly.
Grammatical Compatibility Semantic representations must be linked cleanly to other
kinds of grammatical information (most notably syntax).
Computational Tractability It must be possible to process meanings and to check semantic equivalence efficiently and to express relationships between semantic representations
straightforwardly.
Underspecifiability Semantic representations should allow underspecification (ways of
leaving semantic distinctions unresolved), in such a way as to allow flexible, monotonic resolution of such partial semantic representations.
The first and second criteria are the object of much ongoing work in semantics, only a
small subset of which claims to be computational in its aims. But computational linguists
have to balance these requirements with those imposed by the third and fourth criteria.
Expressive accuracy in particular has often been sacrificed in order to achieve computational
tractability. This has been especially noticeable in natural language generation and machine translation, both of which require some straightforward way of decomposing semantic
representations and relating partial structures. Conventional forms of standard semantic
representation languages have proved problematic for these tasks. As we will discuss below,
1
one major difficulty is in ensuring that a grammar can generate from valid logical forms
while keeping the module that constructs these forms independent of the grammar. Another
problem is to relate semantic representations, as is required, for instance, in a semantic transfer approach to Machine Translation (MT). Issues of this sort have led some researchers to
abandon semantically-driven generation in favor of purely lexically-driven approaches, such
as Shake-and-Bake (e.g., Whitelock 1992). Others have used semantic formalisms which
achieve tractability at the cost of expressive adequacy, in particular by omitting the scope of
quantifiers and disallowing higher-order predicates in general (e.g., Phillips 1993 and Trujillo
1995).
Conventional semantic representations are also problematic for parsing, since they require
information that cannot be obtained by compositional processing of sentences in isolation.
In particular, they require that quantifier scope be specified. However, not only is it very
difficult to resolve quantifier scope ambiguities, it is also often unnecessary in applications
such as MT, since the resolution of quantifier scope usually has no effect on the translation.
Thus there has been considerable work in the last fifteen years on developing representations
which allow scope to be underspecified. See, for instance, Alshawi and Crouch (1992), Reyle
(1993), Bos (1995), Pinkal (1996) and the papers collected in van Deemter and Peters (1996)
(though we will not assume familiarity with any of this work in this paper).
In our view, these issues are linked: a framework for semantic representation which makes
it easy to decompose, relate and compare semantic structures also naturally lends itself to
scope underspecification. In both cases, the key point is that it should be possible to ignore
scope when it is unimportant for the task, at the same time as ensuring that it can be
(re)constructed when it is required. In this paper, we describe a framework for representing
computational semantics that we have called Minimal Recursion Semantics (MRS).1 MRS is
not, in itself, a semantic theory, but can be most simply thought of as a meta-level language
for describing semantic structures in some underlying object language. For the purposes
of this paper, we will take the object language to be predicate calculus with generalized
quantifiers.2
The underlying assumption behind MRS is that the primary units of interest for computational semantics are elementary predications or eps, where by ep we mean a single
relation with its associated arguments (for instance, beyond(x, y)). In general, an ep will
correspond to a single lexeme. MRS is a syntactically ‘flat’ representation, since the eps are
never embedded within one another. However, unlike earlier approaches to flat semantics,
MRS includes a treatment of scope which is straightforwardly related to conventional logical
representations. Moreover, the syntax of MRS was designed so that it could be naturally
expressed in terms of feature structures and, as we shall illustrate, smoothly integrated with
1
MRS was first presented in October 1994 and a partial description of it was published in Copestake et
al. (1995). The current paper is closely based on a 1999 draft distributed via the authors’ web pages. Several
developments have occurred since then, but we have not attempted to cover them fully here, since we believe
that this paper is self-contained as an introduction to MRS. §7 gives a brief overview of some work using
MRS.
2
This should not be taken as suggesting that we think it is impossible or undesirable to give MRS a modeltheoretic semantics directly. But given that our main interest is in the computational and compositional use
of MRS, it is more appropriate to show how it relates to a relatively well-known language, such as predicate
calculus, rather than to attempt a direct interpretation.
2
a feature-based grammar, e.g., one written within the framework of Head-driven Phrase
Structure Grammar (HPSG). The point of MRS is not that it contains any particular new
insight into semantic representation, but rather that it integrates a range of techniques in a
way that has proved to be very suitable for large, general-purpose grammars for use in parsing, generation and semantic transfer (e.g., Copestake et al. 1995, Copestake 1995, Carroll
et al. 1999). It also appears that MRS has utility from a non-computational perspective (see
Riehemann 2001, Bouma et al. 1998, and Warner 2000, among others.).
In the next section of the paper, we motivate flat semantics in more detail. In §3 we
introduce MRS itself, and in §4 we provide more formal details, and discuss semantic composition. We then turn to the implementation of MRS within a typed feature structure logic.
We introduce this in §5 and follow in §6 with concrete examples of the use of MRS within a
large HPSG for English. §7 discusses related work and in §8 we conclude by recapitulating
the main features of MRS and discussing current and future work.
2
Why Flat Semantics?
To illustrate some of the problems involved in using conventional semantic representations
in computational systems, we will consider examples which arise in semantic transfer approaches to MT. The term semantic transfer refers to an approach where a source utterance
is parsed to give a semantic representation and a transfer component converts this into a
target representation. This is then used as input to a generator to produce a string in the
target language. Semantic transfer provides a particularly stringent test of a computational
semantic representation, especially in a broad-coverage system. There has been considerable discussion of the problems within the MT literature (Trujillo (1995) has an especially
detailed account), so we will provide only a brief overview here.
To begin with, consider the following trivial example. An English grammar might naturally produce the logical form (LF) in (1a) from fierce black cat, while a straightforward
transfer from the natural Spanish representation of gato negro y feroz shown in (1b) would
produce the LF in (1c), which the English grammar probably would not accept:
(1) a λx[fierce(x) ∧ (black(x) ∧ cat(x))]
b λx[gato(x) ∧ (negro(x) ∧ feroz(x))]
c λx[cat(x) ∧ (black(x) ∧ fierce(x))]
The strictly binary nature of ∧ leads to a spurious ambiguity in representation, because the
bracketing is irrelevant to the truth conditions. But a generator could only determine this
by examining the logical properties of ∧. The problem is that the form of these semantic
representations implicitly includes information about the syntactic structure of the phrase,
even though this is irrelevant to their semantic interpretation.
In the example above, the individual relations are in a one-to-one equivalence between
the languages. But often this is not the case, and then a similar representation problem also
affects the transfer component. Consider the possible translation equivalence between (one
sense of) the German Schimmel and white horse, which might be represented as (2a). There
is a potential problem in applying the rule to white English horse because of the bracketing
(see (2b)).
3
(2) a [white(x) ∧ horse(x)] ↔ Schimmel(x)]
b [white(x) ∧ (English(x) ∧ horse(x))]
There are also more complex cases. For instance, the English phrase beginning of spring
can be translated into German as Frühlingsanfang. In (3) we show two possible scopes for
the sentence the beginning of spring arrived which arise on the assumption that spring is
taken as contributing a definite quantifier:3
(3) the beginning of spring arrived
def q(x, spring(x), the(y, beginning(y,x), arrive(y)))
the(y, def q(x, spring(x), beginning(y,x)), arrive(y))
Even without going into details of the representation in German or of the transfer rules,
it should be apparent that it is potentially difficult to make the mapping. If both scopes
are allowed by the English grammar, then it is not possible to write a single transfer rule
to map from English to German without a powerful transfer language which allows higherorder unification or the equivalent. But if the grammar only allows one scope, the transfer
component needs to know which is the ‘valid’ scope when going from German to English.
We refer the reader who wants further discussion of these issues to Trujillo (1995). Our
point here is just that there are two related problems: how do we make it as easy as possible
to write general transfer rules, and how do we ensure that the system can generate from
the input LF. The second problem has received more attention: it might seem that the
generator could try logically equivalent variants of the LF until it finds one that works, but
this is not feasible since the logical form equivalence problem is undecidable, even for first
order predicate calculus (see Shieber (1993) for more details). Thus we have the problem
of guaranteeing that a grammar can generate from a given logical form. One line which
was investigated was the development of isomorphic grammars for the target and source
languages (e.g., Landsbergen 1987). But this has proven to be extremely difficult, if not
impossible, to accomplish in a broad-coverage MT system: grammar development is quite
complex enough without trying to keep the rules parallel across multiple languages.
The difficulties with isomorphic grammars led some researchers to develop the ‘Shakeand-Bake’ approach to semantic transfer (e.g., Whitelock 1992). Shake-and-Bake operates by
considering transfer between bags of instantiated lexical signs rather than LFs. This avoids
problems of the sort we have been considering, which essentially arise from the structure
of the LF. However, from our perspective, this is not a good solution, because it is quite
specific to MT and it imposes stringent conditions on the grammar (at least in the efficient
form of Shake-and-Bake processing described by Poznanski et al. (1995)). An alternative is
to modify the form of the semantic representation, in particular to use a non-recursive, or
flat representation such as those developed by Phillips (1993) or Trujillo (1995) (the latter
uses flat semantic structures in conjunction with Shake-and-Bake processing). In (4) we
show structures for some of our previous examples in a flat semantic representation roughly
equivalent to that used by Trujillo:
3
Here and below, we use a syntax for generalized quantifiers without lambda expressions, where the first
argument position is used for the bound variable. This is sort of notation is common in computational
semantics: see, for instance, Nerbonne (1993).
4
(4) a fierce black cat
fierce(x), black(x), cat(x)
b the beginning of spring arrives
the(y), beginning(y, x), def(x), spring(x), arrive(e, y)
Note that the structure is a list of elementary predications, which can be taken as being
conjoined. Adverbs are all assumed to take events as arguments. It should be easy to see
why this representation makes the representation of transfer rules simpler and avoids at
least some of the problems of ensuring that the input LF is accepted by the generator, on
the assumption that the generator simply has to accept the members of the flat list in an
arbitrary order. Chart generation (e.g., Kay 1996, Carroll et al. 1999) is a suitable approach
for such a representation since it allows the alternative orderings to be explored relatively
efficiently.
But the omission of scope means the representation is semantically inadequate. For
example, consider the representation of:
(5) Every white horse is old.
There is only one possible scope for every in this sentence, which is shown in (6) using
generalized quantifiers:
(6) every(x, white(x) ∧ horse(x), old(x))
We should, therefore, be able to retrieve this reading unambiguously from the semantic
representation that the grammar constructs for this sentence. However, if we have the totally
flat structure shown in (7), it is impossible to retrieve the correct reading unambiguously,
because we would get the same structure for (8), for instance.
(7) every(x), horse(x), old(x), white(x)
(8) Every old horse is white.
Representations which completely omit scope lose too much information for some applications, even though they are suitable for MT (at least up to a point). They are also clearly
inadequate from the perspective of theoretical linguistics. We therefore want an approach
which is in the spirit of Trujillo and Phillip’s work, but we require a flat representation that
preserves sufficient information about scope to be able to construct all and only the possible
readings for the sentence. We can also observe that, although full logical equivalence is going
to be undecidable for any language that is sufficiently powerful to represent natural language,
it seems that this may not be the most desirable notion of equivalence for many problems
in computational linguistics, including generation in an MT system. It is apparent from the
work on flat semantics and on Shake-and-Bake that the primary interest is in finding the
correct lexemes and the relationships between them that are licensed in a very direct way by
the syntax. Thus, what we require is a representation language where we can ignore scope
when it is irrelevant, but retrieve scopal information when it is needed. Of course this also
suggests a language that will support underspecification of quantifier scope during parsing,
though we won’t motivate the need for this in detail, since it has been amply discussed by
various authors (e.g., Hobbs 1983).
5
Before we go into detail about how MRS fulfills these requirements, we should emphasize
that, although we have concentrated on motivating flat semantics by considering semantic
transfer, we believe that the lessons learned are relevant for multiple applications in NLP.
Shieber (1993) discusses logical form equivalence with respect to generation. In small-scale,
domain-specific generation applications, the developer can tune the grammar or the module
which produces the semantic representation in order to try and ensure that the generator will
accept the LF. But this is somewhat like the isomorphic grammar approach in MT and we
believe that, for a large-scale, general-purpose grammar, it is impractical to do this without
adopting some form of flat representation.
3
MRS Representation
We will approach our informal description of MRS by starting off from a conventional predicate calculus representation with generalized quantifiers and discussing a series of modifications that have the effect of flattening the representation. It will be useful to regard the
conventional representation as a tree, with scopal arguments forming the branches. See, for
instance, (9):
(9) a every big white horse sleeps
V
V
b every(x, (big(x), (white(x), horse(x))), sleep(x))
c
every(x)
@
@
V
big(x)
sleep(x)
@
@V
@
@
white(x)
horse(x)
This simple tree notation is straightforwardly equivalent to the conventional notation,
assuming that:
1. All connectives are represented using a prefixed notation and can be treated syntactiV
cally like (scopal) predicates. For instance, we write (white(x), horse(x)) rather than
white(x) ∧ horse(x).
2. All non-scopal arguments in a predication precede all scopal arguments.
3. The position in the scopal argument list is paralleled by the left-to-right ordering of
daughters of a node in the tree.4
4
Here and below, the notion of tree we are assuming is a single-rooted connected directed graph where
no node has more than one parent. This is formally equivalent to the definition in Partee et al. (1993: 16.3),
though we have more complex structures than atomic symbols labeling tree nodes, and we are only interested
in precedence of the daughters of a single node, rather than over the entire tree.
6
As we mentioned above, we assume a three-argument notation for generalized quantifiers,
where the first argument corresponds to the bound variable. We will use the terminology
restriction and body to refer to the two set arguments, where we use body rather than scope
to avoid confusion between this and the more general concept of scope.
Given that, as discussed in the previous section, binary ∧ gives rise to spurious ambiguities, we can improve on this representation by allowing ∧ to be n-ary. For instance, when
representing (9a), rather than (9b)/(9c), we can use (10a)/(10b):
V
(10) a every(x, (big(x), white(x), horse(x)), sleep(x))
b
every(x)
@
@
V
sleep(x)
H
big(x)
HH
H
white(x) horse(x)
Our next move is to simplify this notation by omitting the conjunction symbol, on the
basis of a convention whereby a group of elementary predications on a tree node is always
assumed to be conjoined. Thus the equivalent of the expression above is shown in (11):
(11)
every(x)
HH
HH
big(x),white(x),horse(x)
sleep(x)
Notice that order of the elements within the group is not semantically significant. However, the structure is a bag, rather than a set, because there might be repeated elements.
Besides notational simplicity, the reason for making conjunction implicit is to make it
easier to process the sort of examples that we saw in the last section. This special treatment
is justifiable because logical conjunction has a special status in the representation of natural
language because of its general use in composing semantic expressions. If the other logical
connectives (∨, etc.) are used directly at all in semantic representation, they are restricted to
occurring in quite specific, lexically-licensed, contexts. Our use of groups of eps is reminiscent
of the use of sets of conditions in Discourse Representation Theory (Kamp and Reyle 1993).
To take the next step to a flat representation, we want to be able to consider the nodes
of a tree independently from any parent or daughters. In MRS, this is done by reifying the
links in the tree, by using tags which match up scopal argument positions with the eps (or
conjunctions of eps) that fill them. We refer to these tags as handles, since they can be
thought of as enabling us to grab hold of an ep. Each ep has a handle which identifies it as
belonging to a particular tree node (henceforth label), and if it is scopal, it will have handles
in its scopal argument positions. We will use h1, h2 etc to represent the handles, and show
7
labels as preceding an ep with : separating the label and the ep. For instance, the equivalent
of (10) can be drawn as an unlinked tree as shown in (12):
(12)
h0:every(x)
h1
@
@
h1:big(x), h1:white(x), h1:horse(x)
h2
h2:sleep(x)
If multiple eps have the same label, they must be on the same node and therefore
conjoined. Since position in the unlinked tree drawing in (12) is conveying no information
which isn’t conveyed by the handles (other than to specify the order of scopal arguments),
we can use a simple flat list of labeled eps as in (13).
(13) h0: every(x, h1, h2), h1: big(x), h1: white(x), h1: horse(x), h2: sleep(x)
The use of the same handle to label all eps in a conjunction means we don’t need any extra
syntactic devices to delimit the conjuncts in the list of eps.
Formally we actually have a bag of eps, since the order is semantically irrelevant. The
structure in (14) is equivalent to the one given in (13).
(14) h1: white(x), h0: every(x, h1, h2), h1: big(x), h2: sleep(x), h1: horse(x)
The choice of particular names for handles is also semantically irrelevant, so we could equally
well write (15) (which is an alphabetic variant of (14)).
(15) h0: white(x), h1: every(x, h0, h3), h0: big(x), h3: sleep(x), h0: horse(x)
This flat representation facilitates considering the eps individually. To derive a flat
representation something like Trujillo’s (modulo the use of event variables, which we will
return to in §6), we just ignore the handles. However, it is just a syntactic variant of
the notation we started with, since if we want to draw a conventional tree we just plug
the the pieces together according to the handles. We can then reconstruct a conventional
representation, as before. There is one caveat here: we have left open the issue of whether the
relations themselves can have structure. If they cannot, then the MRS notation as described
so far does not allow for predicate modifiers. For instance, there is no way of specifying
something like very(big)(x). For the purposes of the current discussion, we will ignore this
issue and assume that predicate modifiers are not allowed in the object language.
These flat labeled structures are MRSs, but the reason why MRS is not a notational
variant of the conventional representation is that it allows underspecification of the links in
order to represent multiple scopes (rather than requiring that each handle in an argument
position also be the label of some ep). We use the term handle for the tags in both fully
specified and underspecified links.
To illustrate scope underspecification informally, consider the representation of the sentence in (16):
8
(16) every dog chases some white cat
This has the fully specified readings shown in (17) (wide scope some) and in (18) (wide
scope every), where in both cases we show the conventional notation, the tree (with implicit
conjunction) and the MRS equivalent:
(17) a some(y, white(y) ∧ cat(y), every(x, dog(x), chase(x, y)))
b
some(y)
white(y), cat(y)
@
@
every(x)
@
@
dog(x)
chase(x,y)
c h1: every(x, h3, h4), h3: dog(x), h7: white(y), h7: cat(y), h5: some(y, h7, h1),
h4: chase(x, y)
(18) a every(x, dog(x), some(y, white(y) ∧ cat(y), chase(x, y)))
b
every(x)
dog(x)
@
@
some(y)
@
@
white(y), cat(y)
chase(x,y)
c h1: every(x, h3, h5), h3: dog(x), h7: white(y), h7: cat(y), h5: some(y, h7, h4),
h4: chase(x, y)
Notice that, in terms of the MRS representation, the only difference is in the handles for
the body arguments of the two quantifiers. So if we want to represent this as a single MRS
structure, we can do so by representing the pieces of the tree that are constant between the
two readings, and stipulating some constraints on how they may be joined together. The
basic conditions on joining the pieces are those that are enforced by the predicate calculus
representation: (1) there must be no cases where an argument is left unsatisfied and (2) an
ep may fill at most one argument position. Given these conditions, we can generalize over
these two structures, as shown in (19):
(19) h1: every(x, h3, hA), h3: dog(x), h7: white(y), h7: cat(y), h5: some(y, h7, hB ),
h4: chase(x, y)
To make the example clear, we have used hA and hB for the handles in the body positions
of the quantifiers.
In terms of the tree representation, what we have done is to replace the fully specified
trees with a partially specified structure. Linking the pieces of the representation can be
9
done in just two ways, to give exactly these two trees back again, provided the restrictions
on valid predicate calculus formulas are obeyed. That is, we can either link the structures
so that hA = h5 and hB = h4 or so that hA = h4 and hB = h1. But we couldn’t make
hA = hB = h4, for instance, because the result would not be a tree. We will make the linking
constraints explicit in the next section. It will turn out that for more complex examples we
also need to allow the grammar to specify some explicit partial constraints on linkages, which
again we will consider below.
So each analysis of a sentence produced by a grammar corresponds to a single MRS
structure, which in turn corresponds to a (non-empty) set of expressions in the predicate
calculus object language.5 If the set contains more than one element, then we say that the
MRS is underspecified (with respect to the object language).
So, to summarize this section, there are two basic representational features of MRS. The
most important is that we reify scopal relationships as handles so that syntactically the
language looks first-order. This makes it easy to ignore scopal relations when necessary, and
by allowing the handles to act as variables, we can represent underspecification of scope.
The second feature is to recognize the special status of logical conjunction and to adapt the
syntax so it is not explicit in the MRS. This is less important in terms of formal semantics and
we could have adopted the first feature, but kept an explicit conjunction relation. However
implicit conjunction combined with scope reification considerably facilitates generation and
transfer using MRS (see Copestake et al. 1995 and Carroll et al. 1999).
4
A More Detailed Specification of MRS
Although sophisticated accounts of the semantics of underspecified scope have been proposed,
for our current purposes it is adequate to characterize the semantics of MRS indirectly by
relating it to the underlying object language. In this section, we will therefore show more
precisely how an MRS is related to a set of predicate calculus expressions. In §4.1 we go
over some basic definitions that correspond in essential respects to concepts we introduced
informally in the last section. In §4.2 we then go on to consider constraints on handles and
in §4.3 we introduce an approach to semantic composition.
4.1
Basic definitions
We begin by defining eps as follows:
Definition 1 (Elementary predication (ep)) An elementary predication contains exactly
four components:
1. a handle which is the label of the ep
2. a relation
5
If an MRS produced by a grammar for a complete sentence does not correspond to any object language
structures, we assume there is an error in the grammar. There is an alternative approach which uses semantic
ill-formedness to deliberately rule out analyses, but this requires a rather unlikely degree of perfection in the
grammar developer in order to be really practical.
10
3. a list of zero or more ordinary variable arguments of the relation
4. a list of zero or more handles corresponding to scopal arguments of the relation
This is written as handle: relation(arg1 . . . argn , sc-arg1 . . . sc-argm ). For example, an ep corresponding to every is written as h2: every(y, h3, h4).
We also want to define (implicit) conjunction of eps:
Definition 2 (ep conjunction) An ep conjunction is a bag of eps that have the same
label.
We will say a handle labels an ep conjunction when the handle labels the eps which are
members of the conjunction.
We can say that an ep E immediately outscopes another ep E 0 within an MRS if the
value of one of the scopal arguments of E is the label of E 0 . The outscopes relation is
the transitive closure of the immediately outscopes relationship. This gives a partial order
on a set of eps. It is useful to overload the term ‘outscopes’ to also describe a relationship
between ep conjunctions by saying that an ep conjunction C immediately outscopes another
ep conjunction C 0 if C contains an ep E with an argument that is the label of C 0 . Similarly,
we will say that a handle h immediately outscopes h0 if h is the label of an ep which has an
argument h0 .
With this out of the way, we can define an MRS structure. The basis of the MRS structure
is the bag of eps, but it is also necessary to include two extra components.
1. The top handle of the MRS corresponds to a handle which will label the highest ep
conjunction in all scope-resolved MRSs which can be derived from this MRS.
2. Handle constraints or hcons contains a (possibly empty) bag of constraints on the
outscopes partial order. These will be discussed in §4.2, but for now we’ll just stipulate
that any such constraints must be obeyed by the eps without defining what form the
constraints take.
In later sections, we will see that further attributes are necessary to define semantic composition with MRSs.
Definition 3 (MRS Structure) An MRS structure is a tuple hGT, R, Ci where GT is the
top handle, R is a bag of eps and C is a bag of handle constraints, such that:
Top: There is no handle h that outscopes GT .
Handle Constraints: The outscopes order between the eps in R respects any constraints in C.
For example, the MRS structure in (19) can be more precisely written as (20), where we
have explicitly shown the top handle, h0, and the empty bag of handle constraints:
(20) hh0, {h1: every(x, h2, h3), h2: dog(x), h4: chase(x, y), h5: some(y, h6, h7), h6: white(y),
h6: cat(y)}, {}i
11
We have also renumbered the handles and rearranged the eps to be consistent with the
convention we usually adopt of writing the eps in the same order as the corresponding words
appear in the sentence.
The definition of a scope-resolved MRS structure, which corresponds to a single expression
in the object language, is now straightforward:
Definition 4 (Scope-resolved MRS structure) A scope-resolved MRS structure is an
MRS structure that satisfies both the following conditions:
1. The MRS structure forms a tree of ep conjunctions, where dominance is determined
by the outscopes ordering on ep conjunctions (i.e., a connected graph, with a single
root that dominates every other node, and no nodes having more than one parent).
2. The top handle and all handle arguments are identified with an EP label.
It follows from these conditions that in a scoped MRS structure all ep labels must be
identified with a handle argument in some ep, except for the case of the top handle, which
must be the label of the top node of the tree. As we have seen, such an MRS can be
thought of as a syntactic variant of an expression in the predicate calculus object language.
For uniformity, we will actually assume it corresponds to a singleton set of object language
expressions.
Notice that we have not said anything about the binding of variables, but we return to
this at the end of this section. Also note that the definition of immediately outscopes we
have adopted is effectively syntactic, so the definition of a scope-resolved MRS is based on
actual connections, not possible ones. Thus, the following MRS is not scope-resolved, even
though there is trivially only one object-language expression to which it could correspond:
(21) hh0, {h0: every(x, h2, h3), h2: dog(x), h4: sleep(x)}, {}i
In order to formalize the idea that an underspecified MRS will correspond to a set of
more than one object-language expression, we will define the relationship of an arbitary
MRS structure to a set of scope-resolved MRSs. The intuition is that the pieces of tree in
an underspecified MRS structure may be linked up in a variety of ways to produce a set of
maximally linked structures, where a maximally linked structure is a scope-resolved MRS.
Linking simply consists of adding equalities between handles. Linking can be regarded
as a form of specialization, and it is always monotonic.6 So if we have an MRS M that
is equivalent to an MRS M 0 with the exception that M 0 contains zero or more additional
equalities between handles, we can say that M link-subsumes M 0 . If M 6= M 0 we can say that
M strictly link-subsumes M 0 . For instance, the MRS shown in (20) strictly link-subsumes
the structure shown in (22a) and is strictly link-subsumed by the structure in (22b):
(22) a hh0, {h1: every(x, h2, h3), h2: dog(x), h3: chase(x, y), h5: some(y, h6, h7), h6: white(y),
h6: cat(y)}, {}i
b hh0, {h1: every(x, h2, h3), h2: dog(x), h4: chase(x, y), h5: some(y, h6, h7), h8: white(y),
h8: cat(y)}, {}i
6
It is possible to define certain non-monotonic forms of MRS, but we will not consider that further in
this paper.
12
Interesting linkings involve one of three possibilities:
1. equating handle-taking argument positions in eps with labels of other eps,
2. equating labels of eps to form a larger ep conjunction, and
3. equating the top handle with the label of an ep conjunction.
It is also possible to equate two handle-taking argument positions, but since such a structure
is not a tree it cannot be a scope-resolved MRS, nor can it link-subsume a scope-resolved
MRS. A scope-resolved structure is maximally linked in the sense that adding any further
equalities between handles will give a non-tree structure.
Thus we have the following definition of a well-formed MRS (that is, one which will
correspond to a non-empty set of object-language expressions):
Definition 5 (Well-formed MRS structure) A well-formed MRS structure is an MRS
structure that link-subsumes one or more scope-resolved MRSs.
We can say that if a well-formed MRS M link-subsumes a set of scope-resolved MRSs,
M1 , M2 , . . . Mn , such that M1 corresponds to the (singleton) set of object-language expressions O1 , and M2 corresponds to O2 and so on, then M corresponds to the set of objectlanguage expressions which is the union of O1 , O2 , . . . On . In general, the MRSs we are
interested in when writing grammars are those that are well-formed by this definition.
Because we have not considered variable binding, this definition allows for partial MRSs,
which will correspond to subsentential phrases, for instance. This is desirable, but we generally want to exclude specializations of complete MRSs (i.e., MRSs which correspond to
sentences) which link the structure in such a way that variables are left unbound. In order
to do this, we need to consider generalized quantifiers as being a special type of relation.
An ep corresponding to a generalized quantifier has one variable argument, which is the
bound variable of the quantifier, and two handle arguments, corresponding to the restriction
and body arguments. If a variable does not occur as the bound variable of any quantifier,
or occurs as the bound variable but also occurs outside the restriction or the body of that
quantifier, then it is unbound. No two quantifiers may share bound variables. Thus a scoperesolved MRS without unbound variables will correspond to a closed sentence (a statement)
in predicate calculus.
This section has outlined how an MRS may be mapped into a set of object language
expressions, but we also need to be able to go from an object language expression to a (scoperesolved) MRS expression. This is mostly straightforward, since it essentially involves the
steps we discussed in the last section. However, one point we skipped over in the previous
discussion is variable naming: although standard predicate calculus allows repeated variable
names to refer to different variables when they are in the scope of different quantifiers,
allowing duplicate variables in a single MRS gives rise to unnecessary complications which
we wish to avoid, especially when we come to consider feature structure representations.
So, since there is no loss of generality, we assume distinct variables are always represented
by distinct names in an MRS. When converting a predicate calculus formula to an MRS,
variables must first be renamed as necessary to ensure the names are unique.
13
In order to go from a set of object language expressions to a single MRS structure, we have
to consider the issue of representing explicit constraints on the valid linkings. The problem
is not how to represent an arbitrary set of expressions, because we are only interested in
sets of expressions that might correspond to the semantics of individual natural language
phrases. We discuss this in the next section.
4.2
Constraints on scope relations
One major practical difference between underspecified representations is the form of constraints on scope relations they assume. We left this open in the preceding section, because
MRS could potentially accommodate a range of possible types of constraints.7 Any form of
scope constraints will describe restrictions on possible linkings of an MRS structure. As we
have seen, there are implicit constraints which arise from the conditions on binding of variables by generalized quantifiers or from the tree conditions on the scope-resolved structures,
and these are in fact enough to guarantee the example of scope resolution we saw in §3.
But additional constraint specifications are required to adequately represent some natural
language expressions.
For instance, although in example (20) we showed the restriction of the quantifiers being
equated with a specific label, it is not possible to do this in general, because of examples such
as (23a). If we assume nephew is a relational noun and has two arguments, it is generally
accepted that (23a) has the two scopes shown in (23b):
(23) a every nephew of some famous politician runs
b every(x, some(y, famous(y) ∧ politician(y), nephew(x, y)), run(x))
some(y, famous(y) ∧ politician(y), every(x, nephew(x, y), run(x)))
c hh1, {h2: every(x, h3, h4), h5: nephew(x, y), h6: some(y, h7, h8), h7: politician(y),
h7: famous(y), h10: run(x)}, {}i
d every(x, run(x), some(y, famous(y) ∧ politician(y), nephew(x, y)))
some(y, famous(y) ∧ politician(y), every(x, run(x), nephew(x, y)))
This means the quantifier restriction must be underspecified in the MRS representation.
However, if this is left unconstrained, as in, for instance, (23c), unwanted scopes can be
obtained, specifically those in (23d), as well as the desirable scopes in (23b).8
There are a variety of forms of constraint which we could use to deal with this, but in
what follows, we will use one which was chosen because it makes a straightforward form
of semantic composition possible. We refer to this a qeq constraint (or =q ) which stands
for equality modulo quantifiers. A qeq constraint always relates a handle in an argument
position to a label. The intuition is that if a handle argument h is qeq some label l, either
that argument must be directly filled by l (i.e., h = l), or else one or more quantifiers ‘float
in’ between h and l. In the latter case, the label of a quantifier fills the argument position
and the body argument of that quantifier is filled either by l, or by the label of another
quantifier, which in turn must have l directly or indirectly in its body.
7
Indeed, in earlier versions of MRS, we used different types of constraints from those described here.
We are taking the variable binding condition into account here: if we do not, there are even more possible
scopes.
8
14
top
...
run(x)
every(x)
@
@
...
nephew(x,y)
some(y)
...
@
@
famous(y), politician(y)
Figure 1: Schematic representation of the qeq relationships in every nephew of some famous
politician runs
An improved MRS representation of (23a) using qeq constraints is shown in (24):
(24) hh1, {h2: every(x, h3, h4), h5: nephew(x, y), h6: some(y, h7, h8), h9: politician(y), h9: famous(y),
h10: run(x)}, {h1 =q h10, h7 =q h9, h3 =q h5}i
Notice that there is a qeq relationship for the restriction of each quantifier and also one that
holds between the top handle and the verb.
More formally:
Definition 6 (qeq condition) An argument handle h is qeq to some label l just in case
h = l or there is some (non-repeating) chain of one or more quantifier eps E1 , E2 . . . En
such that h is equal to the label of E1 , l is equal to the body argument handle of En and for
all pairs in the chain Em , Em+1 the label of Em+1 is equal to the body argument handle of
Em .
The =q relation thus corresponds either to an equality relationship or a very specific form
of outscopes relationship. Schematically, we can draw this as in Figure 1, where the dotted
lines in the tree indicate a =q relation.
As a further example, consider the MRS shown in (25), where there is a scopal adverb,
probably:
(25) every dog probably chases some white cat
hh0, {h1: every(x, h2, h3), h4: dog(x), h5: probably(h6), h7: chase(x, y), h8: some(y, h9, h10),
h11: white(y), h11: cat(y)}, {h0 =q h5, h2 =q h4, h6 =q h7, h9 =q h11}i
15
top
...
probably
...
chase(x,y)
every(x)
...
@
@
dog(x) some(y)
...
@
@
white(y), cat(y)
Figure 2: Schematic representation of the qeq relationships in every dog probably chases some
white cat
This example is shown using the dotted line notation in Figure 2. This has the six scopes
shown in (26).
(26) probably(every(x, dog(x), some(y, white(y) ∧ cat(y), chase(x, y))))
every(x, dog(x), probably(some(y, white(y) ∧ cat(y), chase(x, y))))
every(x, dog(x), some(y, white(y) ∧ cat(y), probably(chase(x, y))))
probably(some(y, white(y) ∧ cat(y), every(x, dog(x), chase(x, y))))
some(y, white(y) ∧ cat(y), probably(every(x, dog(x), chase(x, y))))
some(y, white(y) ∧ cat(y), every(x, dog(x), probably(chase(x, y))))
Notice that, although probably is scopal, the scope cannot be resolved so that the ep for
probably comes between two handles that are in a =q relationship. We say that the ep for
probably is a fixed scopal ep, as opposed to cat (for instance), which has a non-scopal ep,
and every and other quantifiers which have non-fixed (or floating) scopal eps.
The point of using the qeq constraint is that it enables us to write simple rules of semantic
composition (described in the next section), while succinctly capturing the constraints on
scope that otherwise could require mechanisms for quantifier storage.
16
4.3
Constraints on handles in semantic composition
In order to state the rules of combination involving handles, we will assume that MRSs have
an extra attribute, the local top, or ltop, which will be the topmost label in an MRS which
is not the label of a floating ep. For instance, in (25), the ltop is the label corresponding to
the ep for probably, h5. In an MRS corresponding to a complete utterance, the top handle
will be qeq to the local top. We will assume that when an MRS is composed, the top handle
for each phrase in the composition is the same: that is, the top handle we introduced in §4.1
is a ‘global’ top handle gtop, in contrast to the local top for the phrase, which is the label
of the topmost ep in that phrase which is not a floating ep. For phrases that only contain
floating eps, the ltop is not bound to any label. So the revised MRS structure is a tuple
hGT, LT, R, Ci, where LT is the local top. As before, GT is the global top handle and R
and C are the ep bag and handle constraints. For convenience, in the representations in this
section, we will consistently use h0 for the global top.
Lexical items We assume that each lexical item (other than those with empty ep bags)
has a single distinguished main ep, which we will refer to as the key ep. All other eps either
share a label with the key ep or are equal to or qeq to some scopal argument of the key ep.
With respect to key eps there are three cases to consider:
1. The key is a non-scopal epor a fixed scopal ep. In this case, the ltop handle of
the MRS is equal to the label of the key ep. For example, hh0, h1, {h1: dog(x)}, {}i,
hh0, h2, {h2: probably(h3)}, {}i.9
2. The key is a floating ep. In this case, the ltop handle of the MRS is not equated to
any handle. For example, hh0, h3, {h4: every(y, h5, h6)}, {}i.
3. If the lexical item has an empty ep bag there is no key ep and the lexical item’s MRS
structure has an unequated ltop handle: hh0, h1, {}, {}i.
Phrases The bag of elementary predications associated with a phrase is constructed by
appending the bags of eps of all of the daughters. All handle constraints on daughters are
preserved. The global top of the mother is always identified with the global top on each
daughter. To determine the ltop of the phrase and any extra qeq constraints, we have to
consider two classes of phrase formation, plus a root condition:
1. Intersective combination: The local tops of the daughters are equated with each
other and with the local top of the phrase’s MRS. That is, if the MRS for the mother
is hGT0 , LT0 , R0 , C0 i and the daughters are hGT1 , LT1 , R1 , C1 i . . . hGTn , LTn , Rn , Cn i,
then GT0 = GT1 = GT2 . . . GTn , LT0 = LT1 = LT2 . . . LTn , R0 = R1 + R2 . . . Rn ,
C0 = C1 + C2 . . . Cn (where + stands for append). For example if the MRS for white is
hh0, h1, {h1: white(x)}, {}i and that for cat is hh0, h2, {h2: cat(y)}, {}i then the MRS
for white cat is hh0, h1, {h1: cat(x), h1: white(x)}, {}i. Note that this class is not just
intended for modification: it also covers the combination of a verb with an NP complement, for example.
9
For simplicity in this section, we show the lexical entries as having empty handle constraints, but in a
lexicalist grammar partially specified handle constraints may be present in the lexical entries.
17
2. Scopal combination: In the straightforward case, this involves a binary rule, with one
daughter containing a scopal ep which scopes over the other daughter. The daughter
containing the scopal ep is the semantic head daughter. The handle-taking argument
of the scopal ep is stated to be qeq to the ltop handle of the scoped-over phrase. The
ltop handle of the phrase is the ltop handle of the MRS which contains the scopal
ep. That is, if the MRS for the mother is hGT0 , LT0 , R0 , C0 i, the scoping daughter is hGTs , LTs , {LTs : EP (. . . , h) . . .}, Cs i, where EP (. . . , h) stands for an ep with a
handle-taking argument, and the scoped-over daughter is hGTns , LTns , Rns , Cns i, then
GT0 = GTs = GTns , LT0 = LTs , R0 = Rs + Rns and C0 = Cs + Cns + {h =q LTns }.
For example, if the MRS for sleeps is hh0, h5, {h5: sleep(x)}, {}i and the MRS for
probably is hh0, h2, {h2: probably(h3)}, {}i, then the result for probably sleeps would
be hh0, h2, {h2: probably(h3), h5: sleep(x)}, {h3 =q h5}i. The extension for rules with
multiple daughters where one scopal ep takes two or more arguments is straightforward: there will be a separate qeq constraint for each scopal argument.
For quantifiers, the scopal argument is always the restriction of the quantifier and
the body of the quantifier is always left unconstrained. For example, given every is
hh0, h1, {h2: every(x, h3, h4)}, {}i and dog is hh0, h5, {h5: dog(y)}, {}i then every dog
is hh0, h1, {h2: every(x, h3, h4), h5: dog(x)}, {h3 =q h5}i.
3. Root: The root condition stipulates that the global top is qeq the local top of the
root phrase. That is, if the MRS for the sentence is hGT0 , LT0 , R0 , C0 i then C0 must
include GT0 =q LT0 .
Figure 3 shows in detail the composition of every dog probably chases some white cat.
We have shown coindexation of the ordinary variables here as well as the handles, although
we have not fully specified how this happens in the composition rules above since this requires discussion of the link to syntax. As stated here, the constraints do not allow for
any contribution of the construction itself to the semantics of the phrase. However, this is
straightforwardly accommodated in MRS: the construction itself contributes semantics in
exactly the same way as a daughter in a normal rule. Hence the construction may add one
or more eps that become part of the ep bag of the constructed phrase. Examples of this
will be discussed in §6.6.
The effect of the semantic composition rules stated above can elucidated by the partial
tree notation. Any MRS will have a backbone tree of non-floating scopal eps, which are in
a fixed relationship relative to each other, with the backbone terminated by non-scopal eps.
All quantifiers will have a similar backbone associated with their restriction, but their body
argument will be completely underspecified. All non-scopal eps are in a qeq relationship,
either with a quantifier’s restriction or with an argument of a fixed-position scopal ep.
Figures 1 and 2 from the previous section should help make this clear.
It should be clear that if a non-quantifier ep is not directly or indirectly constrained to
be qeq to a scopal argument position or a quantifier’s restriction, then the only way it can
enter that part of the structure in a resolved MRS is if it is ‘carried’ there via the restriction
of a quantifier. A quantifier in turn is restricted by the variable binding conditions and the
requirement that it have a non-empty body. The combination of these conditions leads to
various desirable properties, e.g., that nothing can get inside the restriction of a quantifier
18
h0, h5, {h1: every(x, h2, h3), h4: dog(x), h5: prbly(h6), h7: chase(x, y), h8: some(y, h9, h10),
h11: white(y), h11: cat(y)}, {h0 =q h5, h2 =q h4, h6 =q h7, h9 =q h11}
"
"
"
b
b
b
"
"
"
b
b
b
"
"
b
b
bb
""
h5, {h1: every(x, h2, h3), h4: dog(x)}, h13, {h13: prbly(h6), h7: chase(w, y), h8: some(y, h9, h10),
{h2 =q h4}
h11: white(y), h11: cat(y)}, {h6 =q h7, h9 =q h11}
Z
Z
Z
Z
Z
Z
Z
Z
Z
Z
Z
Z
Z
Z
Z
Z
h5, {h1: every(x, h2, h3)} h4, {h4: dog(z)} h13, {h13: prbly(h6)} h7, {h7: chase(w, y),
every
dog
probably
h8: some(y, h9, h10),
h11: white(y), h11: cat(y)}, {h9 =q h11}
h7, {h7: chase(w, v)}
h12, {h8: some(y, h9, h10),
h11:
white(y),
h11: cat(y)}, {h9 =q h11}
chases
h12, {h8: some(y, h9, h10)} h11, {h11: white(u), h11: cat(u)}
some
Z
h11, {h11: white(u)}
white
Z
Z
Z
Z
Z
Z
Z
h14, {h14: cat(t)}
cat
Figure 3: Example of composition. Empty handle constraints are omitted. The global top
handle, h0, is omitted except on the root.
19
unless it corresponds to something that is within the corresponding noun phrase syntactically.
For example, (27a) has the MRS shown in (27b), which has exactly the 5 scopes shown in
(27c) to (27g):
(27) a every nephew of some famous politician saw a pony
b hh0, h1, {h2: every(x, h3, h4), h5: nephew(x, y), h6: some(y, h7, h8), h9: politician(y),
h9: famous(y), h10: see(x, z), h11: a(z, h12, h13), h14: pony(z)}, {h1 =q h10,
h7 =q h9, h3 =q h5, h12 =q h14}i
c every(x, some(y, famous(y) ∧ politician(y), nephew(x, y)), a(z, pony(z), see(x, z)))
d a(z, pony(z), every(x, some(y, famous(y) ∧ politician(y), nephew(x, y)), see(x, z)))
e some(y, famous(y) ∧ politician(y), every(x, nephew(x, y), a(z, pony(z), see(x, z))))
f some(y, famous(y) ∧ politician(y), a(z, pony(z), every(x, nephew(x, y), see(x, z))))
g a(z, pony(z), some(y, famous(y) ∧ politician(y), every(x, nephew(x, y), see(x, z))))
We leave it as an exercise for the reader to work through the representations to see why only
these five scopes are valid. This essentially corresponds to the effects of quantifier storage
when used with generalized quantifiers.10
The approach described here means that there can be no ambiguity involving the relative
scope of two non-quantifiers unless there is lexical or syntactic ambiguity. For instance, the
two readings of (28a), sketched in (28b), have to arise from a syntactic ambiguity.
(28) a Kim could not sleep
b could(not(sleep(kim)))
not(could(sleep(kim)))
This seems to be justified in this particular case (see e.g., Warner 2000), but there are other
phenomena that may require these conditions to be relaxed. However, we will not discuss
this further in this paper.
5
MRS in Typed Feature Structures
As stated in the introduction, we are using MRS for grammars developed within a typed
feature structure formalism. In this section we will briefly reformulate what has already
been discussed in terms of typed feature structures, describing some implementation choices
along the way. This encoding is formalism-dependent but grammar-independent: it is
equally applicable to categorial grammars encoded in typed feature structure, for instance,
although some of our encoding choices are motivated by following the existing HPSG tradition. In the next section we will point out various descriptive advantages of MRS as
we move to a discussion of its use in a particular grammar, namely the English Resource
Grammar (ERG) developed by the LinGO project at CSLI (Flickinger et al. 2000; see also
http://lingo.stanford.edu, from with the grammar itself can be downloaded, along with
a parser/generator).
10
For discussion, see Hobbs and Shieber (1987).
20
5.1
Basic Structures
In feature structure frameworks, the semantic representation is one piece of a larger feature
structure representing the word or phrase as a whole. Here we will concentrate on the
semantic representations, ignoring links with the syntax.
First we consider the encoding of eps. We will assume that the ep’s relation is encoded
using the feature structure’s type, and that there is one feature corresponding to the handle
that labels the ep and one feature for each of the ep’s argument positions. For example,
(29) illustrates the feature structure encoding of the eps introduced by the lexical entries for
dog and every:
"
(29) a

b
dog rel
LBL handle
ARG0 ref-ind
#

every rel
handle 
 LBL
 ARG0 ref-ind 
RSTR handle
BODY handle
By convention, the types corresponding to relations which are introduced by individual
lexemes have a leading underscore followed by the orthography of the lexeme. Different senses
may be distinguished, but we omit these distinctions here for purposes of readability. All
types denoting relations end in ‘ rel’. As usual in typed feature structure formalism encodings
of semantics, coindexation is used to represent variable identity; we take a similar approach
with handles. Notice that there is no type distinction between handles in label position and
argument handles. This allows the linking of an MRS to be defined in terms of the feature
structure logic, since adding links corresponds to adding reentrancies/coindexations.
We should mention that we avoid the use of very specific features for relations, such as
corpse for the subject of die. This use of such features is traditional in the HPSG literature,
but it is incompatible with stating generalizations involving linking between syntax and
semantics in lexical entries. For instance, separate linking rules would have to be stated for
die and snore declaring the reentrancy of the subject’s index with the relevant attribute in
the verb’s relation. We therefore assume there is a relatively small set of features that are
appropriate for the different relations. The general MRS approach is neutral about what this
inventory of relation features consists of, being equally compatible with the use of generalized
semantic (thematic) roles such as actor and undergoer (e.g., following Davis 2001) or
a semantically-bleached nomenclature, such as arg1, arg2. We will adopt the latter style
here, to maintain consistency with usage in the ERG.
An MRS is defined as corresponding to a feature structure of type mrs with features
hook, rels and hcons, where the value of hook is of type hook, which itself defines
(at least) the features gtop and ltop. gtop introduces the global top handle, ltop the
local top. hook is used to group together the features that specify the parts of an MRS
which are visible to semantic functors, following the approach to semantic composition in
Copestake et al. (2001). hook also includes the index, which corresponds to a distinguished
normal (non-handle) variable, as illustrated below. rels is the feature that introduces the
bag of eps, which is implemented as a list in the feature structure representation.11 hcons
11
In earlier versions of MRS, the two features that we have called gtop and rels were called handel (or
21
introduces the handle constraints, which are also implemented as a list. The individual qeq
constraints are represented by a type qeq with appropriate features harg for the handle of
the argument position and larg for the label handle.
The MRS feature structure for the sentence every dog probably sleeps is shown along with
its non-feature-structure equivalent in (30):


mrs
#
"
hook


 HOOK GTOP 1 handle





LTOP 7 handle





every rel
"
#"
#"
# 


probably rel
sleep rel
dog rel

 LBL 2 handle 
(30) 
 RELS <  ARG0 3 ref-ind , LBL 6 handle , LBL 7 handle , LBL 9
>






ARG1 8
ARG1 3
ARG0 3
RSTR 4 handle


BODY handle


"
#"
#"
#


qeq
qeq
qeq


 HCONS < HARG 1 , HARG 4 , HARG 8 >

LARG
7
LARG
6
LARG
9
hh1, h7, {h2: every(x, h4, h5), h6: dog(x), h7: probably(h8), h9: sleep(x)},
{h1 =q h7, h4 =q h6, h8 =q h9}i
For ease of comparison, the handle numbering has been made consistent between the two
representations, though there is no number for the body of the relation for every in the
feature structure representation, because there is no coindexation. Conversely, the variable
which is represented as x in the non-feature-structure form corresponds to the coindexation
labeled with 3 in the feature structure form.
There are two alternative representation choices which we will mention here, but not
discuss in detail. The first is that we could have chosen to make the relation be the value of
a feature (such as reln) in the ep, rather than the type of the ep as a whole, as in Pollard
and Sag (1994). This is shown in (31):
"
(31)
RELN dog rel
LBL handle
ARG0 ref-ind
#
This allows the possibility of complex relations, such as the equivalent of very(big)(x), and
reduces the number of distinct types required in a grammar with a large lexicon, but would
slightly complicate the presentation here. Second, instead of treating scopal arguments
via handle identity, as we have been assuming, it would be possible to get a similar effect
without the lbl (label) feature, by making use of coindexation with the whole ep. This is
only possible, however, if we use an explicit relation for conjunction, instead of relying on
handle identity.
5.2
Composition
We can straightforwardly reformulate the principles of semantic composition given in §4.3
in terms of feature structures. The classes of ep (i.e., fixed scopal, non-scopal etc) can be
distinguished in terms of their position in the type hierarchy. The semantics for the lexical
hndl) and liszt (or lzt). lbl was also called handel or hndl.
22
entry for dog, probably and every with the hook features appropriately coindexed with the
elementary predications are shown in (32):



mrs
"
GTOP handle

 HOOK LTOP 2


INDEX 3
(32) 
"
#

dog rel

>
 RELS < LBL 2

ARG0 3
HCONS
< >
#




,






mrs

 HOOK GTOP handle


LTOP 2


"
#


probably rel


 RELS < LBL 2
,
>




ARG1 3
# 
"



qeq

 HCONS < HARG 3
>
LARG handle

mrs
"
#
GTOP handle


 HOOK LTOP handle



INDEX 3






every rel




LBL
handle



> 
ARG0 3
 RELS < 





RSTR 4


BODY handle

"
# 


qeq


 HCONS < HARG 4
>
LARG handle
Notice that the index is equated with the arg0 in both every and dog. The lbl of
every rel is not coindexed with the ltop, in accordance with the rules in §4.3. We have
not shown the link to the syntactic part of the sign, but this would cause the larg of the qeq
in probably to be coindexed with the ltop of the structure it modifies. Similarly, the larg
of the qeq in every would be coindexed with the ltop of the Nbar, while the arg0 would
be coindexed with the Nbar’s index. As discussed in detail in Copestake et al. (2001), MRS
composition can be formalised in terms of a semantic head daughter having a particular
syntactic slot12 which is filled by the hook of the non-semantic-head daughter: we will return
to this in §6.2.
The simple type hierarchy shown in Figure 4 sketches one way of encoding the constraints
on scopal and intersective phrases. In these types, the semantic head daughter is dtr1 and
the other daughter is dtr2. The idea is that the hook of the mother is always the hook of the
semantic head daughter, that gtops are always equated, and rels and hcons attributes
are always accumulated. This figure incorporates several simplifying assumptions:
1. It assumes all phrases are binary (though the extension to unary and ternary rules is
straightforward).
2. The ‘. . . ’ notation implies that some sort of list membership operation is necessary, and
that there might be some non-determinism in the identification of the scopal relation,
but the qeq constraint can actually be specified in terms of the relevant syntactic slot.
3. The appending of the accumulator attributes rels and hcons can be implemented by
difference lists in those variants of feature structure formalisms which do not support
an append operator directly.
4. Not all constructions of a grammar need to be either intersective or scopal inherently,
since in a highly lexicalist framework some constructions, such as the rule(s) for combining a lexical head with its complements, might well inherit from the more general
(underspecified) type, leaving the lexical head to determine the form of composition.
However, each instantiation of a rule in a phrase will be intersective or scopal.
Using these definitions of semantic composition in feature structures, the composition of
the sentence every dog probably sleeps is shown in Figure 5. Notice that since we are now
12
Called a ‘hole’ in Copestake et al. (2001).
23


phrase
i
h


HOOK 1
GTOP 0




 CONT 

 RELS 2 + 3




HCONS 4 + 5








HOOK 1



 DTR1|CONT  RELS 2 


HCONS 4






DTR2|CONT HOOK|GTOP 0 RELS 3
HCONS
5
@
@
@
@
@
"
intersective-phrase
DTR1|CONT|HOOK|LTOP
DTR2|CONT|HOOK|LTOP
#
6
6


scopal-phrase

i
h



HOOK LTOP 7



"
#



scopal-rel





 RELS < ... LBL 7
, ... >  


 DTR1|CONT 
ARG1 8



"
#



qeq



 HCONS < HARG 8 , ... >  




LARG 9


h
i


DTR2|CONT|HOOK
LTOP
9
Figure 4: Illustrative constraints on composition
talking about feature structures and unification, we have illustrated how the coindexation
propagates through the structure in this figure. In addition, we represent the root condition
as an extra level in the tree; this is not essential, but provides a locus for the constraint
identifying the highest ltop of the sentence with the value of gtop.
Note that the global top does not play any direct role in the examples of composition
that we will discuss here, so for ease of presentation, we will henceforth omit reference to
it.13
In this example, notice that the lexical entries for the quantifier every and the scopal
adverb probably each introduce a qeq constraint which is then passed up through the tree
by virtue of the simple append on hcons defined in the principles of semantic composition. Further, we only illustrate here lexical entries which each introduce a single ep but
a grammar may well include semantically complex lexical entries which introduce two or
more relations. In such cases, we require that the semantics of these semantically complex
lexical entries conform to the well-formedness principles already defined for phrases, though
we may also need an additional type of handle constraint for simple equality. To see this,
consider non-recursive: if prefixation by non- is treated as productive, the semantics for
this can be treated as consisting of two relations, where the non rel directly outscopes the
recursive rel.
13
The global top (or conceivably even a set of non-local tops) may play an important role in DRT-style
semantic representations (Kamp and Reyle (1993: p. 107 and chapter 3)), for example enabling a constraint
that all pronoun or proper name handles be identified with the global top handle.
24


mrs



 HOOK 5 GTOP 1


LTOP 7




every rel

# 
#"
#"
"


sleep rel
probably rel
dog rel


 LBL 2

, LBL 6
 RELS <  ARG0 3
>
,
,
LBL 9
LBL 7






ARG1 3
ARG1 8
ARG0 3
RSTR 4


BODY
handle


"
#"
#"
#


qeq
qeq
qeq



 HCONS < HARG 1 , HARG 4 , HARG 8 >
LARG
7
LARG
6
LARG
9
 mrs

 HOOK 5


every rel
"
#"

dog rel
probably

LBL 2

 RELS < 


,
,
6
7
LBL
LBL
ARG0
3




ARG0 3
ARG1 8
RSTR
4

BODY handle

"
#"
#

qeq
qeq

 HCONS < HARG 4 , HARG 8 >
LARG
6
LARG
"
b
b
b
"
"
b
b

 HOOK
10

mrs
 HOOK

LARG
"
"
"
"
b
b
b
b
"
"
"



GTOP 1
 HOOK 10 LTOP

handle 

 


every rel




LBL
2
 


>
 RELS <  ARG0 3

 



RSTR 4


BODY
handle


"
#


qeq


 HCONS < HARG 4 > 
9
b
b
"
"
"
b
b
every
LARG
LARG
6
"
"

5"
#"
# 


probably rel
sleep rel


 RELS < LBL 7
,
>
LBL 9


ARG1 8
ARG1 3


#
"


qeq


 HCONS < HARG 8 >





every rel
"
# 

dog
rel


LBL 2

 RELS < 

 ARG0 3
, LBL 6
>





ARG0
3
RSTR 4


BODY handle


"
#


qeq


 HCONS < HARG 4 >

mrs
sleep rel
LBL 9
ARG1 3





>






b
"

,
#
9
"
"
 mrs
rel
#"
 probably

mrs

 

  HOOK 5 GTOP 1
 HOOK GTOP 1



LTOP 6

LTOP 7

"
#  


"
#
 

dog rel

probably rel
 RELS <



>
LBL
6

  RELS < LBL 7
>


ARG0 3


ARG1 8


HCONS < >
"
#


qeq


 HCONS < HARG 8 > 

dog
mrs
LARG
6
b
b
b
b
 sleeps

mrs


 HOOK GTOP 1



LTOP 9

"
# 


sleep rel
 RELS <

>
LBL 9



ARG1 3
HCONS
9
Figure 5: Example of composition using feature structures
25
< >
5.3
Resolution
MRS was designed so that the process of scope-resolution could be formulated as a monotonic
specialization of a feature structure (cf Nerbonne, 1993). It is thus consistent with the general constraint-based approach assumed in HPSG. The discussion of linking of tree fragments
in §4 holds in much the same way for feature structures: linking consists of adding a coindexation between two handles in the feature structure, and the link-subsumption relationship
described between MRSs is thus consistent with the partial order on feature structures,
though the feature structure partial order is more fine-grained.
In principle, it would be possible to implement the instantiation of an underspecified
MRS to produce scoped forms directly in a typed feature structure formalism that allowed
recursive constraints. However, to do this would be complicated and would raise very serious
efficiency issues. The number of scopes of a sentence with n quantifiers and no other scopal elements is n! (ignoring complications, e.g., one quantifier’s scope being included in the
restriction of another) and a naive algorithm is therefore problematic. Because of this, we
have developed external modules for extra-grammatical processing such as scope determination. The situation is analogous to parsing and generation using typed feature structures:
It is possible to describe a grammar in a typed feature structure formalism in such a way
that parsing and generation can be regarded as a form of resolution of recursive constraints.
However, for the the sake of efficiency, most systems make use of special-purpose processing algorithms, such as variants of chart-parsing, rather than relying on general constraint
resolution. And just as the use of a chart can avoid exponentiality in parsing, non-factorial
algorithms can be designed for determining whether an MRS has at least one scope (see
Niehren and Thater, 2003). However, we will not discuss this further in this paper.
6
Using MRS in an HPSG
In this section we describe the use of MRS in a large HPSG, namely the LinGO project’s
English Resource Grammar (Flickinger et al. 200014 ). We will do this through a series of
examples, beginning with an amplification of one we have discussed already, and then going
through a series of somewhat more complex cases.
6.1
A basic example
First, consider (33), which is the representation of the sentence every dog probably sleeps
produced by the LinGO ERG:15 (This structure should be compared with (31).)
14
See also: http://lingo.stanford.edu/.
The attribute and type names used in this paper reflect the version of the ERG as of July 2003, which
incorporates more normalization in naming conventions.
15
26


mrs
 hook


"
#

event



 HOOK  INDEX 0 TENSE past



MOOD indicative 


LTOP 1 handle

 every rel




 LBL 2 




#
"
ref-ind
probably
(33) 
"
# 


dog rel

 LBL 7

 , LBL 6
png
 RELS < 
,
ARG0
3

 ARG1 8
 PNG PN 3sg



 ARG0 3

GEN neut







RSTR 4 handle

BODY handle

#"
#"
#
"

qeq
qeq
qeq

 HCONS < HARG 10 , HARG 4 , HARG 8 >
LARG
7
LARG
6
LARG
9












 

sleep
rel

prpstn m rel
rel
>
,  LBL 9 ,  LBL 1

  ARG0 0   MARG 10  


ARG1 3







The basic structures are as described in the previous section: the overall structure is of type
mrs and it has features hook, rels and hcons as before. However, the global gtop is
omitted, as it is redundant for this grammar (as we will explain shortly).
Complex indices In the previous section, we assumed that the variables were represented
by coindexed atomic values. In the LinGO ERG, as is usual in HPSG, these variables have
their own substructure, which is used to encode attributes for agreement (Pollard and Sag
1994: chapter 2) or tense and aspect. The details of the encoding are not relevant to the
MRS representation, however.
Event variables In this example, the value of the index attribute is an event variable,
which is coindexed with the ARG0 attribute of the die relation. The ERG, in common with
much other work on computational semantics, uses a neo-Davidsonian representation which
requires that all verbs introduce events. One effect of this is that it leads to a situation where
there are two different classes of adverbs: scopal adverbs such as probably, which are treated
as taking arguments of type handle in MRS, and non-scopal adverbs, such as quickly, which
are treated as taking events as arguments. This is analogous to the distinction between
non-intersective and intersective adjectives.
Notice that the event variables are not explicitly bound. We assume that there is an
implicit wide-scope quantifier for each event variable. This is not entirely adequate, because
there are some examples in which the scope of events could plausibly be claimed to interact
with the explicit quantifiers, but we will not pursue that issue further here.
Tense As can be seen in this example, the grammar encodes tense and mood by instantiating values on the event variable of the verb. Effectively these values simply record the
information derived from the morphology of a verb (or an auxiliary). However, enough information is present to allow conversion to a more complex form if necessary. For instance,
assume that the effect of the tense feature having the value past is cached out in a conventional logical representation as past(e). A more semantically interesting representation might
be hold(e, t), precedes(t, now), where hold and precedes are primitives in the logic of events
and times, and now is a variable representing the sentence time. But this representation can
27
be derived from the simpler one given, since the now of the sentence, although semantically
a variable, is unaffected by the sentence content. Similarly, the only point of explicitly using
the additional temporal variable t in the grammar would be if it turns out to be necessary
to refer to it directly in some other part of the semantics. It might seem that a temporal
adverbial, such as on Sunday should refer to t, but even if this is correct, it does not follow
that it is necessary to make the on rel take t as an argument rather than the event, e,
since there is a function from e to t. Furthermore, the grammar is significantly simpler if
on rel takes an event argument like other adverbial prepositions. We have belabored this
point somewhat, because it is representative of a more general issue concerning semantics in
a computational grammar: simple, generic-looking structures are preferable for processing,
maintainability, and comprehensibility, provided that enough information is included for a
more explicit representation to be derived.
Message relations The example shown in (33) contains an ‘extra’ ep (compared to (31))
which has a relation prpstn m rel. This conveys the information that the sentence is a
proposition, rather than a question, for instance (questions are indicated by int m rel). Such
relations, generically referred to as message relations, are an adaptation of the Vendlerian
theory of messages developed by Ginzburg and Sag (2000).
In general, message relations behave like normal scopal relations with respect to their
arguments (introduced with the attribute marg for message argument), but they are a
special case when they are themselves arguments of some sort of scopal ep, since they are
always equal to the scopal ep’s argument position rather than being qeq to it. This avoids
our use of message relations introducing additional scope possibilities. The root condition is
also modified in a similar way, so that the global top of the MRS is equal to rather than qeq
to the label of the message relation. Since all MRSs corresponding to root structures have
an outermost scoping message, this has the effect that all the quantifiers in the sentence have
to scope under the prpstn m rel. In fact this means that the feature gtop is redundant
in this grammar, since the ltop of a root structure is also the global top.
6.2
Composition in the ERG
The principles of composition in the ERG are consistent with the approach described in
Copestake et al. (2001). To describe this informally, we will need the concept of a slot.
Slots represent the syntax-semantics link: they control how variables in the eps in the
semantic head daughter (with which the slot is associated) get coindexed with the hook of
the non-head-daughter. For instance, in a head-modifier rule, the semantic head daughter
is the modifier, and the slot corresponds to to the mod feature. The mod slot of the
modifier is coindexed with the hook of the modifiee. In the ERG, the slot mechanism is
implemented by typed feature structures as usual in HPSG. However, slots are a convenient
generalization that enable us to describe semantic composition without having to discuss
the feature structure architecture and which can be implemented in non-feature structure
formalisms.
The general principles of semantic composition can be stated as follows:
1. The rels value of a phrase is the concatenation (append) of the rels values of the
28
daughters.
2. The hcons of a phrase is the concatenation (append) of the hcons values of the
daughters.
3. The hook of a phrase is the hook of the semantic head daughter, which is determined
uniquely for each construction type.
4. One slot of the semantic head daughter of a phrase is identified with a hook in the other
daughter. For scopal combination, this will lead to a qeq relation between the scopal
argument in an ep and the ltop of that other daughter. For intersective combination,
an argument in an ep will be identified with the index of that other daughter, and
the ltop of that daughter will be identified with the ltop of the semantic head.
5. Unfilled slots get passed up to the mother.
These rules need some elaboration for the ERG since it is possible for phrases to themselves introduce semantic content directly. This is done via the c-cont (constructionalcontent) attribute of the phrase: an example is discussed below in §6.6. However, the
c-cont attribute’s value meets the constraints on lexical structures that have previously
been described and c-cont behaves for purposes of composition just like the semantics of
an additional daughter. It is possible for the c-cont to be the semantic head of a phrase.
6.3
Intersective and scopal modifiers
Kasper (1996) investigates the internal semantic structure of modifiers, observing that previous analyses of modification in HPSG fail to adequately account for modifier phrases that
contain modifiers of their own, as in his example (34):
(34) Congress approved the potentially controversial plan
He notes that in the analysis of modifier semantics given in Pollard and Sag (1994), the
argument of potentially ends up including not only the psoa for the adjective controversial
but also the psoa for plan. This analysis predicts incorrectly that in the above example the
plan itself is only a potential one, which means that it fails to predict, for example, that a
sentence like (34) entails that Congress approved a plan.
We can also describe the problem in terms of MRS semantics. In HPSG, the syntactic
feature mod is used to allow a modifier to specify the kind of sign that it can modify. Thus
the mod value of an adjective phrase is instantiated by the synsem of the noun it modifies. In
recursive modification, the mod feature of the phrase is identified with that of the modified
structure: for instance, the mod feature for potentially controversial is identified with that
of controversial. This leads to the semantic problem: if an adjective is intersective, like
controversial, the ltop of the adjective and the noun should be equated in a phrase like the
controversial plan. But if this is achieved via a mod specification in the the lexical entry of
the adjective, then the result is wrong for the potentially controversial plan, since this would
mean that plan and controversial share a label and thus when potentially is given scope over
the ep for controversial it would also end up with scope over the ep for plan.
29


mrs
"
#
hook

 HOOK INDEX 0


LTOP 1

#"
#"
"

allegedly rel
difficult-rel
problem

,
,
LBL 4
LBL 1
 RELS < LBL 1

ARG1 3
ARG1 0
ARG0 0

#
"

qeq

 HCONS < HARG 3 >
LARG

4
"
#
hook

 HOOK INDEX 0


LTOP 1

"
#"

allegedly rel
difficult

,
LBL 4
 RELS < LBL 1

ARG1 3
ARG1 0

"
#

qeq

 HCONS < HARG 3 >
LARG


mrs
"
#
hook

 HOOK INDEX 0


LTOP 1

"

allegedly

 RELS < LBL 1

ARG1 3
HCONS
< >
@
@


mrs




# 

rel

>



mrs




# 

rel

>





4




# 

rel

>





"
hook

 HOOK INDEX 0


LTOP 1

"

problem

 RELS < LBL 1

ARG0 0
HCONS
@
@
#




# 

rel

>

< >

mrs
"
hook

 HOOK INDEX 0


LTOP 4

"

difficult

 RELS < LBL 4

ARG1 0
HCONS
#




# 

rel

>

< >
Figure 6: MRS for allegedly difficult problem.
Kasper proposes that this and related difficulties with the original analysis of modifier
semantics can be rectified by distinguishing the inherent semantic content of a modifier
from the combinatorial semantic properties of the modifier. Enriching the mod feature to
include attributes icont (internal content) and econt (external content), he shows how
this distinction can be formalized to produce a more adequate account of recursive modifier
constructions while maintaining the semantic framework of Pollard and Sag.
Kasper’s account could be reformulated in MRS, but we provide an alternative which
captures the correct semantics without having to draw the internal/external content distinction. Unlike Kasper, we do have to assume that there are two rules for modification:
one for scopal and one for non-scopal modifiers. But this distinction has fewer ramifications
than Kasper’s and is independently required in order to efficiently process modifiers for generation, as described by Carroll et al. (1999). The crucial difference between the rules is
that the intersective modifier rule equates the ltop values of the two daughters, while the
scopal version does not. This removes the need for coindexation of ltops in the the lexical
entries of intersective adjectives and thus avoids Kasper’s problem. In Figure 6 we show the
composition of the MRS for allegedly difficult problem.
30
6.4
Complements and Scope
Verbs which take sentential complements are analysed as handle-taking in MRS in much the
same way as scopal adverbs. This is illustrated in (35) below: for simplicity, we ignore the
message relation in this section.

(35)
PHON thinks
 HEAD verb

 ARG-ST < CAT NP
CAT S
,

HOOK|LTOP
HOOK|INDEX 1




mrs


0
 HOOK|LTOP







think
rel





0
LBL



 RELS < 

>


ARG1
1


CONT




ARG2
2


"
# 



qeq



 HCONS < HARG 2 > 

LARG 4

4



>















Note that the scope of quantifiers within complement clauses is unconstrained, as in the
three-way scope ambiguity of examples like (36):
(36) Everyone thought Dana liked a friend of mine from East Texas.
However, the scope of an adverb within a complement clause is bounded by that clause’s
ltop, as discussed earlier. Hence we correctly predict that adverbs like probably in examples
like (37) are unambiguously within the scope of think rel:
(37) Everyone thought Dana probably left.
Note further that the famed scope ambiguity of examples like (38) is properly handled
within MRS:
(38) A unicorn appears to be approaching.
The lexical analysis of raising commonly assumed within HPSG identifies the index bound
by the existential quantifier with that of the unexpressed subject of the VPs appears to be
approaching, to be approaching, be approaching and approaching. Given this, it follows that
this index is also the argument of approach rel. Thus, the MRS for a sentence like (38)
is as described in (39):
 mrs

1 handle 
 HOOK|LTOP


a q rel
"
#"
#"

unicorn rel
appear rel
approach

LBL 2

 RELS < 


,
,
,
LBL
LBL
LBL
6
7
9
ARG0
3


(39) 

ARG0 3
ARG1 8 handle
ARG1 3
RSTR
4
handle

BODY handle

#"
#"
#
"

qeq
qeq
qeq

 HCONS < HARG 1 , HARG 4 , HARG 8 >
LARG
7
LARG
6
LARG
9
rel
#





>






For purposes of resolution, the existential quantifier in (39) is subject only to variable
binding conditions and the requirement that it end up with some handle as its body. Hence it
follows without further stipulation that (39) is ambiguous: the value of a q rel’s body is ei31
ther 7 , in which case a q rel outscopes appear rel, or else 9 , in which case appear rel
outscopes a q rel. For essentially identical reasons, scope may be resolved in two distinct
ways when quantified NPs are extracted, e.g., in (40):
(40) A unicorn, only a fool would look for.
Previous work on semantics in HPSG has relied heavily on the technique of ‘Cooper
Storage’, a method for allowing a variable to stand in for a quantifier’s contribution to the
semantic content of a sentence, while the quantifier which binds that variable is placed in
a ‘store’ (cf. Cooper 1983). In the analysis presented by Pollard and Sag (1994), stored
quantifiers are passed up to successively higher levels of structure until an appropriate scope
assignment locus is reached (e.g., a VP or S). There, quantifier(s) may be retrieved from
storage and integrated into the meaning, receiving a wide scope interpretation. This analysis
entails the introduction of various features, e.g., (q)store, whose value is a set of generalized
quantifiers. Further constraints must be added to ensure that the set of retrieved quantifiers
of any given sign constitutes a list of quantifiers that is prepended to the head daughter’s
quants list. The data structures in Pollard and Sag’s quantifier storage analysis are thus
considerably more complicated than those available within an MRS analysis. This gain in
descriptive simplicity, we believe, constitutes a significant advantage for MRS-based semantic
analysis within HPSG.
The interaction of ‘raising’ and quantifier scope provides a further argument in support
of an MRS analysis. Pollard and Sag’s Cooper Storage analysis mistakenly assigns only one
possible scope to a sentence where a raised argument is a quantifier semantically, e.g., a
sentence like (38). Because quantifier storage only allows a quantifier to obtain wider scope
than the one determined by its syntactic position, there is no way to let appear outscope a
unicorn in Pollard and Sag’s analysis.
This problem is also solved by Pollard and Yoo (1998), but at a cost. They propose
to make qstore a feature within local objects. Since the local information of a raised
argument is identified with the unexpressed subject (the subj element) of the raising verb’s
VP complement, it follows on their analysis that the quantifier stored by the NP a unicorn is
also stored by the (unexpressed) subject of the verb approaching in (40). In the Pollard and
Yoo analysis, the qstore value of each verb is the amalgamation of the qstore values of its
arguments. Hence the existential quantifier in (40) ‘starts out’ in the qstore of approaching
and may be retrieved inside the scope of appear. For example the quantifier may be retrieved
into the content of the phrase to be approaching.
We must ensure that a quantifier never enters into storage twice, e.g., both in the qstore
amalgamation of approaching and in that of appears in (40), as it would lead to a single
quantifier entering into the meaning of the sentence twice. The cost of the Pollard-Yoo
analysis is the device that must be introduced to block this double interpretation of raised
quantifiers. The device is not explicit in Pollard and Yoo’s discussion, where they say that
‘for a (semantically non-vacuous) lexical head, the qstore is the union of the qstores of
all arguments that are subcategorized for and assigned a semantic role by the head’. But
in more precisely formulated proposals, e.g., that of Przepiórkowski (1999: chapter 9), it is
plain that executing this idea requires the introduction of a host of complex relations or
features. Przepiórkowski’s system employs the relations selected-qs-union, get-selectedqs, selected-arg, thematic, and raised.
32
This cumbersome proliferation of analytic devices is avoided entirely in the MRS analysis
described in §6.4 above. The absence of any double interpretation of quantifiers follows
directly from the fact that (1) the lexical entry for a quantificational determiner contains
exactly one generalized quantifier on its rels list and (2) the rels list of a phrase is always
the sum of the rels list of its daughters (together with its c-cont). Again, MRS allows
the analysis of quantification to be more streamlined and more predictive than previous
treatments of quantifier scope developed within HPSG.
6.5
Control Predicates
One further feature used in the ERG is xarg (external-argument). Following Sag and
Pollard (1991), this feature picks out (the index of) the subject argument within a given
phrase. This corresponds to the unexpressed subject in the various control environments
illustrated in examples like the following:
(41) a
b
c
d
e
f
The dog tried to bark.
We tried ignoring them.
To remain silent was impossible.
They did it (in order) to impress us.
They came home quite drunk/in need of help.
Quite drunk/In need of help, they came home early.
The value of the feature hook is a feature structure that contains the semantic properties
that a given phrase ‘makes visible’ to the outside. Hence, it is the information in hook that
is available for coindexation with some external element in virtue of lexical, semantic or
constructional constraints. For this reason, we locate the feature xarg within hook, on a
par with ltop and index.
For example, the lexical entry for the verb try ensures that in the MRS for a sentence
like The dog tried to bark, the arg1 of try rel (the dog) is identified with the external
argument of the infinitival complement, which is identified with the xarg value of the VP
bark, which in turn is coindexed with the arg1 of bark rel. This is illustrated in Figure 7.
Given the particular analysis of English control and raising embodied in the ERG, a controlled complement always has the synsem of the unexpressed subject on its subj list. Hence,
the controlled element could have been identified without xarg, by a constraint stated in
terms of an extended path, e.g., loc|cat|subj|first|loc|cont|hook|index. However,
there are many languages (e.g., Serbo-Croatian, Halkomelem Salish) where the controlled
element is realized as a pronoun within the controlled complement, whose subj list is presumably empty. Under standard HPSG assumptions, such a pronoun is not accessible from
outside the controlled complement. The feature xarg, by allowing the subject’s index to be
visible from outside the complement, thus allows a uniform account of control in all these
languages.
33

phrase
 PHON tried
 CAT VP



to bark





HOOK
0




 CONT RELS < 3 , 4 > 
HCONS
5
+
6
@
@
@
@
@


PHON

tried
 CAT V


HOOK 0



 CONT 
 RELS 3



HCONS

PHON to bark
 CAT VP[inf]








2
LTOP

HOOK




"
#
XARG
1





try rel
"
# 



bark rel

<
>    CONT 
ARG1 1



RELS
4
<
>

2
LBL

ARG2 2




ARG1 1


5
HCONS
6
Figure 7: Control in the VP tried to bark
6.6
Constructions
As we mentioned briefly above, MRS allows for the possibility that constructions may introduce eps into the semantics. Constructions all have a feature c-cont which takes an mrs
structure as its value and behaves according to the composition rules we have previously
outlined. Most constructions in the LinGO grammar actually have an empty c-cont, but
as an example of constructional content, we will consider the rule which is used for bare noun
phrases, that is, bare plurals and bare mass nouns such as squirrels and rice in squirrels eat
rice. The meaning of these phrases is a very complex issue (see, for example, Carlson and
Pelletier 1995) and we do not propose to shed any light on the subject here, since we will
simply assume that a structure that is syntactically the same as a generalized quantifier
is involved, specifically udef rel, but say nothing about what it means.16 The reason for
making the semantics part of the construction is to allow for modifiers: e.g., in fake guns
are not dangerous, the rule applies to fake guns. The construction is shown in Figure 8
and an example of its application is in Figure 9. Notice how similar this is to the regular
16
In particular, we will offer no account of the distinction between ‘weak’ and ‘strong’ generic sentences.
We would argue, however, that the meaning of such phrases is context-dependent. For instance, squirrels eat
roses is clearly a generic sentence, but at least when uttered in response to What on earth happened to those
flowers?, it does not have to mean that most squirrels are rose eaters. On the other hand, dogs are herbivores
seems clearly false, even though there are some dogs on a vegetarian diet. It is therefore appropriate, given
our general approach, to be as neutral as possible about the meaning of such phrases in the grammar. But
we won’t go into a discussion here about whether it is appropriate to use a true generalized quantifier, as
opposed to some variety of kind reading for instance, since the point here is simply the mechanics of phrasal
contributions to the semantics.
34


bare np rule






mrs







1
HOOK




 SYNSEM  LOCAL  CONT 






RELS 2 + 3


HCONS 4 + 5








mrs




hook




1
HOOK




INDEX
0










udef rel




LBL handle  







 C-CONT 

RELS
2
<
>
ARG0
0








RSTR
6






BODY handle




"
#




qeq




 HCONS 4 < HARG 6 > 




LARG 7














mrs
"
#




hook










 HOOK INDEX 0     





 HEAD-DTR 

 SYNSEM  LOCAL  CONT 


LTOP 7











RELS 3





HCONS
5
Figure 8: The bare-np rule
combination of a quantifier.
Other cases where the LinGO grammar uses construction semantics include the rules for
imperative (another unary rule) and for compound nouns (a recursive binary rule). The
same principles also apply for the semantic contribution of lexical rules. Eventually, we hope
to be able to extend this approach to more complex constructions, such as ‘the Xer the Yer’
(e.g., the bigger the better), as discussed in Fillmore et al. (1988).
6.7
Coordination
Our analysis of coordination is based on the idea that conjunctions involve n-ary relations,
which we treat in terms of a handle-valued feature c-args. Our binary branching syntactic
analysis adds one syntactic argument at a time, as sketched in (42):17
17
This presentation simplifies the implemented ERG coordination analysis in non-essential respects.
35
 bare
np rule











mrs


 SYNSEM 

 LOCAL  CONT  HOOK 1



RELS 2 + 3


HCONS 4 + 5





mrs


 HOOK 1 hook




INDEX 0



 



udef-rel




LBL handle  




>
 C-CONT  RELS 2 < 
 ARG0 0
 



RSTR 6



BODY handle



"
#



qeq






HCONS
4
<
>
6
HARG


LARG
7







mrs

"
#




hook











 HOOK INDEX 0






LTOP 7


"
#"
SYNSEM  LOCAL  CONT 
 HEAD-DTR 



tired rel
squirrel







RELS
3
<
,
7
7
LBL
LBL









ARG0
0
ARG0
0




HCONS
5
<>





































 

# 


rel



>




Figure 9: The bare-np rule applied to tired squirrels







mrs


"
#




hook














HOOK INDEX 0







 SYNSEM 

CONT 

LTOP 1
 LOCAL 











 RELS 2 + 3






HCONS 4 + 5














mrs
"
#






hook

















HOOK INDEX 0




 LCONJ-DTR  SYNSEM 

 LOCAL  CONT 






LTOP 8










(42) 








RELS 2







HCONS 4
















mrs
"
#






hook












 HOOK INDEX 0


















LTOP 1



 RCONJ-DTR 






"
#
CONT

 SYNSEM  LOCAL 



conj rel












, ... >     


 RELS 3 < LBL 1







C-ARGS 8







coord rule



HCONS
5
Note that the ltop of the left conjunct is identified with the handle argument of the key
relation of the right conjunct, which is one of the conj rels (e.g., and rel, or rel) introduced onto the RELS list by the conjunction. Thus our analysis yields mrs structures like
36
the following for a ternary VP like slip, slide, and slither:
mrs
1 handle
 HOOK|LTOP
# 
# "
#"
#"
"


slither rel
slide rel
slip rel
and rel


 RELS < LBL 1
>
,
,
,
LBL 19
LBL 18
LBL 17


ARG1 9
ARG1 9
C-ARGS 8
ARG1 9


"
#"
#"
#


qeq
qeq
qeq



 HCONS < HARG 8
,
,
>
HARG 8
HARG 8
LARG 17
LARG 18
LARG 19


(43)
The identification of the c-args value with the ltop of each left conjunct in the rightbranching coordination structure has the effect of allowing a quantifier within a conjunct to
scope within that conjunct or else to take wider scope. Assuming a quantificational analysis
for indefinites, this prediction is correct, as shown by the quantifier scope ambiguity present
in examples like the following:
(44) a Everyone read a book and left.
b Most people read or saw a movie.
But since adverbs are bounded by their ltops, as we have already seen, our analysis of
coordination makes the further prediction that an adverb that is clearly within a (VP, S,
etc.) conjunct can never outscope the relevant conj rel. As the following unambiguous
examples indicate, this prediction is also correct:18
(45) a Sandy went home and probably fell asleep. (6= Sandy probably went home and fell
asleep.)
b Pat either suddenly went home or forgot to call. (6= Pat suddenly either went home
or forgot to call.)
Finally, examples like the following are correctly predicted to be ambiguous, because there
is a syntactic ambiguity:
(46) Sandy usually goes home at 7 and goes to bed at 10.
Here the adverb can modify either the left conjunct or the coordinate structure, but there
is only one resolved mrs for each syntactic analysis.
7
Related Work
The idea of expressing meaning using a list of elements which correspond to individual morphemes has seemed attractive for some considerable time: it is evident, for example, in
Kay (1970) (though not explicitly discussed in these terms). This concept has been extensively explored by Hobbs (e.g., 1983, 1985) who developed an “ontologically promiscuous”
semantics which supports underspecification of quantifier scope. In order to do this however,
Hobbs had to develop a novel treatment of quantifiers which relies on reifying the notion
of the typical element of a set. Hobbs’ work is extremely ingenious, but the complexity
of the relationship with more conventional approaches makes the representations somewhat
18
However, we have not presented an account here of the apparent quantifier ‘duplication’ in examples like
We needed and craved more protein.
37
difficult to follow and often incompatible with other approaches. As we discussed in §2, a
form of flat semantics has been explicitly proposed for MT by Phillips (1993) and also by
Trujillo (1995). However, as with Kay’s work, these representations do not allow for the
representation of scope.
As we described, the use of handles for representing scope in MRS straightforwardly
leads to a technique for representing underspecification of scope relationships. The use
of an underspecified intermediate representation in computational linguistics dates back at
least to the LUNAR project (Woods et al. 1972) but more recent work has been directed
at developing an adequate semantics for underspecified representations, and in allowing
disambiguation to be formalized as a monotonic accumulation of constraints (Alshawi and
Crouch 1992). Of particular note in this regard is Nerbonne (1993), which describes an
approach to underspecified semantic representation based on feature structures.
Despite our description of MRS in terms of predicate calculus (with generalized quantifiers), MRS is quite close to UDRT (Reyle 1993), since handles play a role similar to UDRT
labels. However, MRS as described here makes use of a different style of scope constraint from
UDRT. Our motivation was two-fold: convenience of representation of the sort of constraints
on scope which arise from syntax, and simplicity in semantic composition using unification.
Partly because of the different notion of scope constraints, the approach to constructing
UDRSs in HPSG given in Frank and Reyle (1994) is significantly different from that used
here. We believe that the MRS approach has the advantage of being more compatible with
earlier approaches to semantics within HPSG, making it easier to incorporate treatments
from existing work.
Bos’ Hole semantics (Bos, 1995) is closely related to MRS, and although the two approaches were originally developed independently, the current formalisation of MRS owes a
lot to his work. From our perspective, perhaps the main difference is that MRS is strongly
influenced by the demands of semantic composition with a tight syntax-semantics interface,
and that MRS is explicitly designed to be compatible with a typed feature structure formalism. An alternative underspecified representation for use with typed feature structures
known (a bit misleadingly) as Underspecified MRS (UMRS) was developed for a German
grammar, and is described in Egg and Lebeth (1995, 1996) and Egg (1998). Abb et al.
(1996) discuss the use of UMRS in semantic transfer. The Constraint-Language for Lambda
Structures (CLLS) approach (Egg et al, 2001) is further from MRS, but the relationship
between Hole semantics, MRS and CLLS has been elucidated by Koller et al. (2003) and
Niehren and Thater (2003). Their work has also demonstrated good complexity results for
satisfiability of constraints expressed in these languages.
There is further work incorporating similar ideas into other frameworks. Kallmeyer and
Joshi (1999) incorporate a semantics similar to MRS into Lexicalized Tree-Adjoining Grammar (LTAG) and Gardent and Kallmeyer (2003) demonstrate an approach to semantic construction for Feature-Based Tree Adjoining Grammar (FTAG) which is quite close to MRS
semantic construction. Baldridge and Kruijff (2002) meld key ideas of MRS with Hybrid
Logic19 and incorporate it into Combinatory Categorial Grammar (CCG). Dahllöf’s (2002)
Token Dependency Semantics builds directly on MRS.
MRS itself has been used in computational grammars other than the ERG: in particular,
19
For more on Hybrid Logic, see: http://www.hylo.net.
38
Siegel and Bender (2002) describe a broad coverage Japanese grammar written using MRS.
Villavicencio (2002) uses MRS in a categorial grammar for experiments on child language
learning. MRS is useful for this purpose because it is relatively independent of syntax and
thus can be used to express possible inputs to the learner without biasing it in favour of a
particular subcategorization pattern.
There is also work that indicates that flat semantics may have advantages in theoretical linguistic research with little or no computational component. Dahllöf’s (2002) work
formalises Davidson’s paratactic approach to intensional contexts. Riehemann (2001) describes a treatment of idioms which crucially utilizes MRS. This approach treats idioms as
phrasal constructions with a specified semantic relationship between the idiomatic words involved. The flatness and underspecifiability of MRS is important for similar reasons to those
discussed with relation to semantic transfer in §2: some idioms appear in a wide range of syntactic contexts and the relationships between parts of the idiom must be represented in a way
that is insensitive to irrelevant syntactic distinctions. Bouma et al. (1998) show that MRS semantics is a crucial ingredient of a constraint-based version of the ‘adjuncts-as-complements’
analysis that has been popular within HPSG.20 They also explore an MRS analysis of classic
examples like The Sheriff jailed Robin Hood for seven years where verbs like jail are lexically decomposed in terms of the two elementary predications h1: cause become(x, y, h2)
and h3: in jail(y). The role that MRS plays in this work is to provide easy access to scope
points in the semantics that do not correspond to any constituent within a syntactic structure. Warner (2000) shows how MRS can facilitate an account of lexical idiosyncrasy in the
English auxiliary system, most notably an account of lexically idiosyncratic modal/negation
scope assignments.
8
Conclusion
In our introduction, we outlined four criteria of adequacy for computational semantics: expressive adequacy, grammatical compatibility, computational tractability, and underspecifiability. In this paper, we have described the basics of the framework of Minimal Recursion
Semantics. We have discussed how underspecifiability and tractability in the form of a flat
representation go together, and illustrated that MRS is nevertheless compatible with conventional semantic representations, thus allowing for expressive adequacy. We have also seen
how MRS can be integrated into a grammatical representation using typed feature structures.
The key ideas we have presented are the following:
1. An MRS system provides flat semantic representations that embody familiar notions
of scope without explicit representational embedding.
2. Quantifier scope can be underspecified but one can specify in a precise way exactly
what set of fully determinate (e.g., scoped) expressions are subsumed by any single
MRS representation.
3. An HPSG can be smoothly integrated with an MRS semantics, allowing lexical and
construction-specific constraints on partial semantic interpretations to be characterized
20
For an overview of such analyses see, Przepiórkowski (1999).
39
in a fully declarative manner.
Because the ERG is a broad-coverage grammar, we have to provide some sort of semantic
analysis for every phenomenon that arises with sufficiently high frequency in our corpora.
There are many areas in which our analyses are currently inadequate and on which we intend
to work further. MRS is being used as part of the Matrix, a grammar core which is intended
to act as a basis on which grammars of various languages can be built (Bender and Flickinger,
2003). A variant of MRS, Robust MRS (RMRS) is currently under development. RMRS
allows more extreme underspecification and is designed to allow shallow analysis systems
to produce a highly underspecified semantic representation which is nevertheless compatible
with the output of deep grammars, such as the ERG.
Acknowledgments
This material is based upon work supported by the National Science Foundation under grants
IRI-9612682 and BCS-0094638, and by the German Federal Ministry of Education, Science,
Research and Technology (BMBF) in the framework of the Verbmobil Project under Grant
FKZ:01iV401. The final version of this paper was prepared while Sag was a Fellow at the
Center for Advanced Study in the Behavioral Sciences, supported by a grant (# 2000-5633)
to CASBS from The William and Flora Hewlett Foundation.
We are grateful for the comments and suggestions of many colleagues. In particular, Rob
Malouf was resposible for the first version of MRS in the ERG, Alex Lascarides has read
and commented on several drafts of the paper and helped develop the formalisation of MRS
composition, and Harry Bunt also influenced the way that MRS developed. We are also
grateful to Emily Bender, Johan Bos, Ted Briscoe, Dick Crouch, Marcus Egg, Bob Kasper,
Ali Knott, JP Koenig, Alex Koller, John Nerbonne, Joachim Niehren, Simone Teufel, Stefan
Thater and Arturo Trujillo. However, as usual, the responsibility for the contents of this
study lies with the authors alone.
References
Abb, B., B. Buschbeck-Wolf and C. Tschernitschek (1996) ‘Abstraction and underspecification in semantic transfer’, Proceedings of the Second Conference of the Association for
Machine Translation in the Americas (AMTA-96), Montreal, pp. 56–65.
Alshawi, H. and R. Crouch (1992) ‘Monotonic semantic interpretation’, Proceedings of the
30th Annual Meeting of the Association for Computational Linguistics (ACL-92), Newark,
NJ, pp. 32-39.
Baldridge, J. and G.-J. M. Kruijff (2002) ‘Coupling CCG and Hybrid Logic dependency
semantics’, Proceedings of the 40th Annual Meeting of the Association for Computational
Linguistics (ACL), Philadelphia.
Bos, J. (1995) ‘Predicate logic unplugged’, Proceedings of the 10th Amsterdam colloquium,
Amsterdam, pp. 133–142.
40
Bouma, G., R. Malouf, and I. A. Sag (1998) ‘Adjunct scope and complex predicates’, Paper
presented at the 20th Annual Meeting of the DGfS. Section 8: The Syntax of Adverbials
– Theoretical and Cross-linguistic Aspects. Halle, Germany.
Carlson, G.N. and F.J. Pelletier (eds) (1995) The Generic Book, University of Chicago Press,
Chicago.
Carroll, J., A. Copestake, D. Flickinger and V. Poznanski (1999) ‘An efficient chart generator
for (semi-)lexicalist grammars’, Proceedings of the 7th European Workshop on Natural
Language Generation (EWNLG’99), Toulouse, pp. 86–95.
Cooper, R. (1983) Quantification and Syntactic Theory, Reidel, Dordrecht.
Copestake, A. (1995) ‘Semantic transfer for Verbmobil’, ACQUILEX II working paper 62
and Verbmobil report 93.
Copestake, A., D. Flickinger, R. Malouf, S. Riehemann, and I.A. Sag (1995) ‘Translation
using Minimal Recursion Semantics’, Proceedings of the The Sixth International Conference on Theoretical and Methodological Issues in Machine Translation (TMI-95), Leuven,
Belgium.
Copestake, A., A. Lascarides and D. Flickinger (2001) ‘An algebra for semantic construction
in constraint-based grammars’, Proceedings of the 39th Annual Meeting of the Association
for Computational Linguistics (ACL 2001), Toulouse, France.
Dahllöf, M. (2002) ‘Token Dependency Semantics and the paratactic analysis of intensional
constructions’, Journal of Semantics, 19, 333-368.
Davis, A. (2001) Linking by Types in the Hierarchical Lexicon, CSLI Publications, Stanford,
CA.
van Deemter, K. and S. Peters (eds) (1996) Semantic ambiguity and underspecification, CSLI
Publications, Stanford, CA.
Egg, M. (1998) ‘Wh-questions in Underspecified Minimal Recursion Semantics’, Journal of
Semantics, 15:1, 37–82.
Egg, M. and K. Lebeth (1995) ‘Semantic underspecification and modifier attachment’, Intergrative Ansätze in der Computerlinguistik. Beiträge zur 5. Fachtagung für Computerlinguistik der DGfS.
Egg, M. and K. Lebeth (1996) ‘Semantic interpretation in HPSG’, Presented at the Third
International Conference on HPSG, Marseilles, France.
Fillmore, C.J., P. Kay, and M.C. O’Connor (1988) ‘Regularity and idiomaticity in grammatical constructions: the case of let alone’, Language, 64:3, 501–538.
Flickinger, D. and A. Copestake and I.A. Sag (2000) ‘HPSG analysis of English’ in W. Wahlster
and R. Karger (ed.), Verbmobil: Foundations of Speech-to-Speech Translation, Berlin,
Heidelberg and New York: Springer Verlag, pp. 254-263.
Frank, A. and U. Reyle (1994) ‘Principle-based semantics for HPSG’, Arbeitspapiere des
Sonderforschungsbereichs 340, University of Stuttgart.
Gardent, C. and L. Kallmeyer (2003) ‘Semantic construction in Feature-Based TAG’, Proceedings of the 10th Conference of the European Chapter of the Association for Computational Linguistics (EACL-03), Budapest, pp. 123–130.
Ginzburg, J. and I.A. Sag (2000) Interrogative Investigations: The form, meaning and use
of English interrogatives, CSLI, Stanford.
41
Hobbs, J. (1983) ‘An improper treatment of quantification in ordinary English’, Proceedings
of the 23rd Annual Meeting of the Association for Computational Linguistics (ACL-83),
MIT, Cambridge, MA, pp. 57–63.
Hobbs, J. (1985) ‘Ontological promiscuity’, Proceedings of the 25th Annual Meeting of the
Association for Computational Linguistics (ACL-85), Chicago, IL, pp. 61-69.
Hobbs, J. and S.M. Shieber (1987) ‘An algorithm for generating quantifier scopings’, Computational Linguistics, 13, 47-63.
Kallmeyer, L. and A. Joshi (1999) ‘Factoring predicate argument and scope semantics: underspecified semantics with LTAG’, Proceedings of the 12th Amsterdam Colloquium, Paul
Dekker (ed.), Amsterdam, ILLC, pp. 169-174.
Kamp, H. and U. Reyle (1993) From Discourse to Logic: An introduction to modeltheoretic semantics, formal logic and Discourse Representation Theory, Kluwer Academic
Publishers, Dordrecht, Germany.
Kasper, R. (1996) ‘Semantics of recursive modification’, unpublished ms. Ohio State University.
Kay, M. (1970) ‘From semantics to syntax’ in M. Bierwisch and K.E. Heidorn (ed.), Progress
in Linguistics, Mouton, The Hague, pp. 114–126.
Kay, M. (1996) ‘Chart Generation’, Proceedings of the 34th Annual Meeting of the Association for Computational Linguistics (ACL-96), Santa Cruz, CA, pp. 200–204.
Koller, A, Niehren, J. and S. Thater (2003) ‘Bridging the gap between underspecification formalisms: Hole Semantics as dominance constraints’, Proceedings of the 10th Conference
of the European Chapter of the Association for Computational Linguistics (EACL-03),
Budapest, pp. 195–202.
Landsbergen, J. (1987) ‘Isomorphic grammars and their use in the ROSETTA translation
system’ in M. King (ed.), Machine Translation Today: The State of the Art, Edinburgh
University Press, pp. 351–372.
Nerbonne, J. (1993) ‘A Feature-Based Syntax/Semantics Interface’, Annals of Mathematics
and Artificial Intelligence (Special issue on Mathematics of Language, A. ManasterRamer and W. Zadrozsny (eds.)), 8, 107-132.
Niehren, J. and S. Thater (2003) ‘Bridging the gap between underspecification formalisms:
Minimal Recursion Semantics as dominance constraints’, Proceedings of the 41st Annual
Meeting of the Association for Computational Linguistics (ACL-03), Sapporo, Japan.
Partee, B., A. ter Meulen and R.E. Wall (1993) Mathematical Methods in Linguistics, Kluwer
Academic Publishers, Dordrecht.
Phillips, J.D. (1993) ‘Generation of text from logical formulae’, Machine Translation, 8 (4),
209–235.
Pinkal, M. (1996) ‘Radical underspecification’, Proceedings of the 10th Amsterdam Colloquium, P. Dekker and M. Stokhof (eds.), Amsterdam, ILLC, pp. 587–606.
Pollard, C. and I.A. Sag (1994) Head-driven Phrase Structure Grammar, Chicago University
Press, Chicago.
Pollard, C. and E.J. Yoo (1998) ‘A unified theory of scope for quantifiers and wh-phrases’,
Journal of Linguistics.
Poznanski, V., J.L. Beaven and P. Whitelock (1995) ‘An efficient generation algorithm for
lexicalist MT’, Proceedings of the 33rd Annual Meeting of the Association for Computational Linguistics (ACL-95), Cambridge, Mass., pp. 261–267.
42
Przepiórkowski, A. (1999) Case Assignment and the Complement-Adjunct Dichotomy – A
non-configurational, constraint-based approach, Doctoral dissertation, Universität Tübingen.
Reyle, U. (1993) ‘Dealing with ambiguities by underspecification’, Journal of Semantics, 10,
123–179.
Riehemann, S. (2001) A Constructional Approach to Idioms and Word Formation, Doctoral
dissertation, Stanford University.
Sag, I.A. and C. Pollard (1991) ‘An Integrated Theory of Complement Control’, Language,
67 (1), 63–113.
Shieber, S.M. (1993) ‘The problem of logical form equivalence’, Computational Linguistics,
19 (1), 179–190.
Siegel, M. and E.M. Bender (2002) ‘Efficient deep processing of Japanese’, Proceedings of the
3rd Workshop on Asian Language Resources and International Standardization. COLING 2002 Post-Conference Workshop, Taipei, Taiwan.
Trujillo, I.A. (1995) Lexicalist Machine Translation of Spatial Prepositions, PhD dissertation,
University of Cambridge.
Villavicencio, A. (2002) ‘The acquisition of a unification-based generalised categorial grammar’, PhD dissertation, University of Cambridge, available as Computer Laboratory
Technical Report 533.
Warner, A. (2000) ‘English auxiliaries without lexical rules’ in R. Borsley (ed.), Syntax
and Semantics Volume 32: The Nature and Function of Syntactic Categories, Academic
Press, San Diego and London, pp. 167-220.
Whitelock, P. (1992) ‘Shake-and-Bake translation’, Proceedings of the 14th International
Conference on Computational Linguistics (COLING-92), Nantes, France.
Woods, W., R.M. Kaplan and B. Nash-Webber (1972) The LUNAR Sciences Natural Language Information System: Final Report (BBN Technical Report 2378), Bolt, Beranek
and Newman Inc., Cambridge, MA.
43
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertisement