Semantic Abstraction and Anaphora 
Mark Johnson 
Brown University 
Martin Kay 
Xerox Pale Alto Research Center and Stanford University 
Abstract 
This paper describes a way of expressing syn- 
tactic rules that ~kssociate semantic formulae 
with strings, but in a manner thai is inde- 
pendent of the syntactic details of these for- 
mulac. In particular we show how the same 
rules construct predicate argument formulae 
in the style of Montague grammar\[131, rap_ 
resentations reminiscent of situation seman- 
tics(Barwise and Perry 121) and of the event 
logic of Davidson \[5\], or representations in- 
spired by the discourse representations pro- 
posed by Kamp \[191. The idea is that seman- 
tic representations are specilied indirectly us- 
ing semantic construction operators, which en- 
force an abstraction barrier between the gram- 
mar and the semantic representations them- 
selves. First we present a simple grammar 
which is compatible with the three different 
sets of constructors for the three formalisms. 
We then extend the grammar to provide one 
treatment that accounts for quantilier raising in 
the three different semantic formalisms 
Introduction 
Grammars specifying the relationship between 
strings and semantic representations often have 
details of these representations embedded in 
them. We show how grammar rules can be 
wrilten in a form which, by abstracting away 
from details of tim semantic representation, ac- 
quires greater modularity and hence theoretical 
perspicuity and practical robustness. In partic- 
ular, we believe that the approach helps clarify 
the relationship between apparently disparate 
theories of semantic representation. 1. The basis 
of our proposal is that each grammatical rule 
should contain, or be paired with, an expres- 
sion written in terms el' sem~mtic construction 
operators. Different operations can be associ- 
ated with these operators and, depending on 
the set in force at a given time, the effect of 
interpreting the expression will be to construct 
a representation in one semantic formalism or 
another. The set of operators contains me,n- 
bets corresponding to such notions as compo- 
sitzon, conjttlwtion, etc. The set is small and in- 
dependent of the semantic formalism. The op- 
erations are associated with the operators inde- 
pendently of the grammar and they determine 
the form of the semantic representation. 
We present three different sets of seman- 
tic constructors here, which we have dubbed 
the predicate-logic, the sets-of-infons and the 
discourse-representatio,z constructors. We be- 
gin by introducing the constructors used in this 
paper: no claims are made for their general 
sufficiency. Not all of the constructors are rel- 
evant to all semantic theories and those not 
needed for a particular one are given degen- 
crate delinitions. The simplest kind of con- 
struction operator is the identity function which 
maps every input i onto just one output, namely 
i. 
The operators are the following: 
1 The kind of separmion between the granmar and the details of 
the semanlic representation proposed here also aplxmrs in the examples 
of Pcreira and Shiebcr\[12\] and in I.cxicaI-Functional Grammar (see 
\[6\]). Our use of different scls of semantic constructors with a single 
grammar is IR)VCI, aS fa\[ aS We are awarg. 
1 17 
emterr~aI(S, EF) relates a semantic represen- 
tation S and an external form EF, e.g. a 
representation that constitutes the parscr's 
output. The internal and cxtemal forms are 
distinguished because the (internal) repre- 
sentation o c will, in general, contain infor- 
mation that plays a role in the process of an- 
alyzing a sentence (e.g. for anaphora track- 
ing) but that is not part of the logical form 
(EF) of the sentence as a whole. 
atom( S, I'rop) specifies that the content of 
the (internal) semantic representation, S, is 
the atomic proposition l)rop. This is used 
to construct the semantic values for lexical 
entries, for example. 
co~jo~:~z(S1, $2, $12) relates three semantic 
representations. It specifies that the content 
of 5'12 is constructed by conjoining 5'1 and 
5'2. This operator occurs crucially in the 
semantics of indefinite determiners. 
7~etv_iT~de,~(S, i) specifics that the content of 
5" is I, a referential index for a non-anaphoric 
NP. The form of a referential index is de- 
fined by the particular semantic theory. 
accessible_iTzdez(S, I) specifies that the con- 
tent of o e is a referential index i of some 
noun phrase that is a potential antecedent of 
an anaphor. Constraints on accessible in- 
dices are defined by the particular semantic 
theory. 
While the primitives discussed in this paper 
have relatively simple definitions, in other 
more elaborate theories they may involve non- 
trivial computation. For example, the com- 
pose primitive might impose certain discourse- 
consistency requirements arising from a more 
restrictive theory of discourse structure than 
those described here. 
A key insight of the Discourse Repre- 
sentation and Situation Semantics accounts, 
but originating with Karttunen\[10\], is that 
anaphoric and quantificational domains coin- 
cide. Thus, in (1), it can be co-indexed with a 
donkey only if a donkey is interpreted as hav- 
ing wide-scope. 
(1) Every man kicked a donkey. It 
developed blue bumps. 
The relationship between these sentences is one 
of (semantic) precedence, and we call the op- 
erator that relates the corresponding semantic 
representations compose: 
corr~pose(S1, $2,5'12) specifies that the infor- 
mation in the representation $12 is the in- 
formation in $1 followed by the informa- 
tion in $2. Compose defines an ordering of 
semantic operations that particular semantic 
theories may or may not be sensitive to. (In 
this paper, the Montague constructors are not 
sensitive to this ordering, while the other two 
types of semantic representations are). 
When a donkey is interpreted as having nar- 
row scope with respect to every man in (1), 
the reference marker introduced by a donkey 
is located in a context subordinate to the sen- 
tence as a whole, and hence not accessible to 
anaphors in the following discourse. To pro- 
vide for this, we introduce the following op- 
erator: 
sttbordiTzate( S, ,5'ztb ?f an~e, S ztb ) specifies that 
S contains an anaphorically and quantili- 
cationally subordinate representation Sub, 
which has the "name" Sz~bName. The 
S~LbName would be distinguished from 
Sub in non-extensional theories of meaning, 
where a meaning is distinguished from its 
propositional content (say), as in the sets- 
of-infons representation described below. 
We turn now to the grammar without 
quantifier-raising. We formulate bolh the 
grammar and the semantic constructors in pure 
Prolog (exploiting the syntactic sugar of Def- 
inite Clause Grammar (Pereira and Shieber 
\[121, pp. 70-79)) because it is expressive 
enough for our purposes and is widely used 
in work of this kind(sec, inter alia Colmerauer 
\[31, Abramson and Dahl \[ll and \[11\]). 
A Grammar using Semantic 
Constructors 
The grammar generates simple transitive 
clauses and subject-relative clauses that do not 
18 2 
involve long-distance dependencies, it is based 
on the Montague-style grammars presented in 
Chapter 4 of Pereira and Shieber\[12\], and 
the treatments of agreement, Wh-dependencies, 
etc., presented there could also be incorporated 
without difficulty. 
* Operators: * 
* for lambda abstracts, * 
* = > for implJcaLion. * ************************************* 
• op(950, xfy, ^) . 
:- op(300, xfx, :::>). 
parse(StLr\] ng,Ext;Sem) '- 
cxt.erna\] (IntSem, ExtSem) , 
s (\]ntSem, StrJng, \[\]) . 
* The grammar * 
s(S) --> np(VP^S), vp(VP) . 
np(NP) --> det (NI^NP), nl(N\]) . 
nl(N) --> rl(N) . 
n\] (X~S) --> n(X^S\]), rc{X~S2), 
{conjoin (SI,S2,S) } . 
vp('(^S) --> v(X^VP), np(VP^S) . 
rc (VP) --> \[that\] , vp (VP) . 
v(X"Y^S) --> \[Verb\], 
{verb (Verb, X^Y^Pred) , 
atom(Pred, S) } . 
n(X"S) --> \[Noun\], 
{noun (Noun,X^Pred) , 
new index(X, SI) , 
atom(Pred, $2) , 
compose(S\].,S2, S) } . 
det ((X^Res) ^ (X^Scope) ~S) - > \[\])et\] , 
{determJnor(1)et, Res~Scope^S) } . 
np((X^SI)^S) --> \[Pronoun\], 
{pronoun (I?ronoun) , 
accessible index (X, S2) , 
compose (S\] , S2, S) }. 
* The lexicon * 
pronoun(he) . 
pronoun(she) . 
pronoun (him) . 
pronoun (her) . 
pronoun(it) . 
verb(likes, X^Y-likes (X,Y)) . 
verb (saw, X^Y^see(X,Y)) . 
verb(beats, X^Y^beat(X,Y)) . 
verb(owns, X^Y^own(X,Y) . 
noun (woman, X^woman(X)) . 
noun (man, X^man (X)) . 
noun (donkey, X^donkey(X) ) . 
determiner (a, Res^Scope^S ) :- 
conjoin(Res, Scope, S) . 
determiner (every, 
Res0^Scope~S ) :- 
compose(S\], $2, S) , 
subordinate(Res, ResName, Sl) , 
compose(Res0, Resl, Res) , 
subordinate (Scope, ScopeName, Resl) , 
atom(ResName > ScopeName, $2) . 
Most of the grammar should be familiar, even 
if it is somewhat more pedantically expressed 
than is usual. Following Pereira and Shieber 
(who were in turn inspired by Montague), VP 
and N incomings are represented by terms of 
the form x ^ S, where X represents a referential 
index and S represents an S meaning. NP 
meanings are represented by terms of the form 
vp^S (or equivalently, (x^s0)^S), where 
vp represents a VP meaning, x a referential 
index, and S and S0 represent S meanings. 
All manipulation of semantic values is per- 
tbrmed by constructor primitives, rather than 
by explicit conslruction of terms. For exam- 
ple, the N1 production that introduces relative- 
clauses invokes con join explicitly to conjoin 
the semantic values of the N and the relative 
clause to yield the semantic value of the N I. 
The sharing of the referential index x bctween 
the N and the VP is performed in the gram- 
mar alone, since it is a syntactic rather than 
semantic property of the construction. 
The semantic component of the production 
that introduces lexical nouns has two parts. SO 
represents the atomic predicate Pced associ- 
ated with the Icxical meaning of the noun. $2 
represents the fact that x is a (possibly new) 
referential index. The component S of the se- 
mantic value associated with the noun contains 
all of the information in SO and S2. 
The production introducing (lexical) pro- 
nouns requires that the referential index x of 
the pronoun be accessible in S0, and speci- 
fies that the S component is the composition 
of S0 and the S0 component of the VP mean- 
ing. (Recall that the semantic representations 
of pronouns, like all NP's, are terms of the 
3 19 
form VP^S, so the SO is a component of the 
meaning of the VP or V phrase that this pro- 
noun is an argument of). 
Undoubtedly the most complex component 
of the grammar is the lexical entry for every. 
Because the structure of the lexical entries for 
all anaphoric scope-inducing quantifiers will be 
similar to the entry for every, wE explain it in 
some detail. 
The quantification induced by the deter- 
miner every is described in terms of the de- 
ternaincr's restriction, which defines the enti- 
ties that the quantification ranges over, and its 
scope, the component of the expression quart- 
tiffed over. (2) indicates the components of the 
utterance corresponding to the restriction and 
the scope of the quantifier every in the absence 
of quantilier-raising. 
(2) Every man that saw a donkey kicked it. 
Restrictor Scope 
The grammars presented here identify the re- 
stricter and the scope of a determiner in the 
syntax; e.g. quantifier-raising arises from the 
grammar permitting multiple a.ssignmcnts of 
components of the utterance to the restrictions 
and scopes of the determiners of that utterance. 
The semantic value associated with lex- 
ical entry for a determiner in the gram- 
mars presented here is a term of the form 
Res~Scol)e~Sentence, where lees is the seman- 
tic value associated with the restrictor and 
Scope is the semantic value associated with 
the scope. A grammar directly constructing 
predicate-logic style semantic representations 
would assign the lexical entry in (3) to the de- 
terminer every, where '==>' is interpreted as 
tire implication operator in semantic represen- 
tations (see Pcreira and Shieber \[1211). 
(3) determiner(every, 
R es ^Scope 7R es=: >Scope)). 
Tiffs 1cxical entry does not suffice for our pur- 
poses, since it provides no information about 
the relative anaphoric scope relationships be- 
tween the restrictor, the scope, and that portion 
of the utterance external to the quantificational 
expression as a whole. 
Anaphors in opaque quantificational expres- 
sions can refer to entities superordinate to 
the quantificational expression, but in general 
anaphors outside of an opaque quantificational 
expression cannot refer to entities introduced in 
either the restriction or scope of the quantili- 
cational expression 2. Anaphors in the scope of 
an opaque quantificational expression can refer 
to entities introduced in the restriction of that 
expression (e.g. as in (3) above), but anaphors 
in the restriction cannot refer to entities intro- 
duced in the scope. 
The compose and subordinate predi- 
cates in the lexical entry for every in the gram- 
mar presented above express subordination re- 
lationships that describe the behavior of opaque 
determiners. The semantic representation S is 
the composition of S1 and $2, where S2 is 
the semantic atom ResName =-> Scope- 
Name. Re s is subordinate to S1, and is itself 
the composition of ResO and Resl, where 
Res0 is the semantic representation of the re- 
stricter. Scope is subordinate to Resl, and 
is the semantic representation of the scope. 
The diagram on the following page sketches 
the relationship between the various semantic 
entities mentioned in the lexical entry for ev- 
ery. Subordination relationships are depicted 
by vertical lines (the name of the subordinate 
space is written alongside the line), and compo- 
sition relationships are indicated by V-shaped 
diagonals. 
The Predicate-Logic Constructors 
These constructors build a predicate-logic 
type of semantic reprcscntation in a fairly 
transparent fashion. Pronouns are treated as 
free variables, there are no constraints on 
their distribution, and anaphoric binding is not 
9" There are exceptions to this: for example, anaphors can refer 
to proper names inlJoduced in the restrictor or scoix~ of opaque de- 
tetvniners. Within the framework described below, this curl be trealed 
by adding a new semantic construction operator add top level, 
which adds a referential irxtex to the most superordinatc level 
20 4 
Scope 
ScopeName 
Res0 Resl 
Res 
ResName ==> ScopeName 
$1 $2 
S 
treated. Thus the definitions of the constructors 
new index, accessible index, com- 
pose and subordinate have degenerate 
definitions. 
A property is identical with the term repro- 
senting it: 
atom(Prop, Prop). 
The conjunction of P and Q is represented by 
the term P &Q. 
conjoin (p, P,PSQ) . 
There are no constraints on new indices. 
new index( , ) . 
Th(-re are no constraints on accessible indices. 
accessible index ( , ) . 
Sequencing is unimportant. 
compose (P, P, P) . 
A Subordinate space can be introduced freely. 
subordinate( ,Sub, Sub) . 
Inlemal and external forms are identical. 
external (P, P) . 
The grammar described above 
predicate-logic constructors yield 
such as the following: 
2- p(\[a,man, owns,a,donkey\],S) . 
S =: man (X) &donkey (Y) Sown (X, Y) 
and the 
analyses 
2- p(\[every,man,that,owns,a,donkey, 
beats,it\],S) . 
S =: (man(X)&donkey(Y)&own(X,Y)) 
==>beat (X,Z) 
Roughly this latter form might be interpreted 
as: if X is a m~m and Y is a donkey and X 
owns Y, then there is a Z such that X beats Z. 
The Sets-of-In fens Constructors 
The constructors for the sets-of-infons and 
the discourse-representation both constrain 
anaphora by requiring that the referential in- 
dices provided by the accessible index 
constructor be indices that were introduced 
by new index in some earlier representation 
(where precedence is defined by the compose 
constmclor). This entails that tile internal form 
of these semantic representations encode infor- 
mation about preceding representations. Both 
constructors thread this information using the 
difference-list technique described in \[8\]. 
The primitive element of tile sets-of-infons 
representation is inspired by the infons of Situ- 
ation Semantics \[21. We represent an infon as 
a term of the form Sit : P, which means that 
p is true in the situation Sit. For example, 
Kim's sleeping in situation sO is represented 
by s0:sleep (kim). For simplicity arbitrar- 
ily named constants (like the gensyms of Lisp) 
are used as the names of situations in this rep- 
resentation: this has the disadvantage that the 
definitions o1 the external and subordinate con- 
strutters are not declaratively specified. 3 
The internal form of a sets of i@)ns rep- 
resentation has three components. We repre- 
sent them in Prolog with a term of the form 
@(sits, Infonstn, InfonsOut). The 
first is a stack whose top element is the situa- 
tion currently being defined, and whose other 
elements are the situations superordinate to this 
one (as defined by the subordinate con- 
structor). The second component is the set 
of all infons introduced in representations pre- 
ceding this one. The infons in this list as- 
sociated with the current or a superordinate 
situation provide the information needed for 
the accessible index constructor. The 
third component of the representation is the set 
3 All lhat is required is that there is an infinite stock of situation 
names, so e.g. integers could have Ixren used as situation names at tile 
expense of a slight complication of lhe represenlation's data structures. 
5 21 
of inRms introduced in preceding representa- 
tions with the addition any infons added to the 
representation by the semantic representation 
constructor. In describing the term @ (Sits, 
InfonIn, InfonsOut), we use the names 
TnfonsIn and InfonsOut to stress the fact 
that they constitute a difference list. 
• - op ( 900, xfx, : ) . 
atom(\] ), @(\[SitI_\],Is, \[(Sit:P)IIs\])). 
compose(@ (Ss, I0s,Ils) , 
@ (Ss, Ils, I2s) , 
@ (Ss, I0s, I2s) ) . 
conjoin(II, I2, I12) "- 
compose(Ii, I2, I12) . 
subordinate (@ ( \[Sit ISits\] , 10s,Ils) , 
Sit, @ (Sits, I0s, Ils) ) :- 
gensym (Sit) . 
new index (Index, S) • - 
atom(i(Index),S) . 
accessible index (Index,@ (Ss, Is, Is)) :- 
member (Sit : i (Index) ,Is), 
member (Sit,Ss) . 
external(@(\[Sit\], \[\], Is), Sit:Is) :- 
gensym(Sit) . 
The atom constructor introduces a new 
atomic proposition p as an infon Sit:P, 
where Sit is the situation currently being 
constructed. Notice that InfonsOut is the 
same as InfonsIn but for the addition of 
(Sit:P). 
The compose constructor threads the dif- 
ference list of infons through both of the rep- 
resentations, so the composed representation 
contains all of the infons added to the sets of 
infons composed. The conjoin constructor 
is equivalent to the compose constructor. 
The subordinate constructor introduces 
a new subordinate representation by pushing a 
new situation name Sit on to the list of (now 
superordinate) situations. The difference list 
of infons is threaded through the subordinate 
representation so that any infons added to it 
will appear in the superordinate representation 
as well. 
The new index constructor adds an atom 
of the form i (Index) to the representation 
S: no constraints are placed on Index. 
The accessible index 4 constructor is 
,1 rl'he predicate member used here, and elsewhere in this paper, 
Ires its standard logical definition: viz: member (X, \[X I \] ) • 
member(X, { , L\]) :- member(X, L). \]f this definkion is 
satisfied for a referential index Index if 
Index was introduced by new index to 
I 
a preceding non-subordinate representation, 
i.e. if the context contains an infon 
Sit:i (Index), where Sit is the current or 
a superordinate situation name. 
The external (Internal, Exter- 
nal) predicate initializes Internal to have 
no superordinate situations and no preceding 
context, and returns the list of infons associated 
with this Internal representation as its external 
form. 
When these constnmtors are used with the 
grammar defined above, the following analyses 
are obtained: 
2- p ( \[a, man, owns, a, donkey\] , S) . 
S = sO: \[S0:own(X,Y),s0:i(Y), 
sO :donkey(Y),S0:i(X) , sO :man(X) \] 
This can be paraphrased as: Situation S0 con- 
tains individuals X and Y; in .sO X is a man, 
Y is a donkey and X owns Y. 
2- p( \[every, man, owns,a,donkey\],S) . 
S = s0: \[S0:sl==>s2,S2:own(X,Y) , 
s2:i(Y) ,s2:donkey(Y), 
sl:i(X) ,Sl:man(X) \] 
This can be paraphrased as: Situation .sO con- 
tains the fact that all situations of type s l are 
also situations of type s2. A situation is of type 
sl if it contains individuals X and Y, and X 
is a man and Y is a donkey. A situation is of 
type s2 if X owns Y. 
?- p( \[every, man, that, owns,a,donkey, 
beats, it\] ,S) . 
S = s0: \[s0:sl==>s2, s2 :beat (X,Y) , 
sl :own (X, Y) ,sl:i (Y) , sl:donkey(Y), 
sl:i(X),sl:man(X)\] 
This can be paraphrased as: Situation s0 
contains the fact that all situations of type ,sl 
are also situations of type s2. A situation is of 
type sl if it contains individuals X and Y, X 
used with the grammars and constructors given in this paper, the SLD 
select.ion rule of Prolog may lead to hen-termination. It is in general 
necessary to delay the evaluation of the member predicate uotil its 
second argument is instantiated, which can tx: done using the freeze 
primitive of Prolog I\[. 
22 6 
is a man, Y is a donkey and X owns Y. 
situation is of type a2 if X beats y.5 
The Discourse-Representation 
Constructors 
A 
The representations built by these construc- 
tors are inspired by the "box representations" 
of Kamp's (1981) Discourse Representation 
Theory \[9\]. A discourse representation "box" 
is represented by the list of items that con- 
stitute its contents. A representation is a 
difference-pair of the lists of the representa- 
tions of the currently open boxes (i.e. the cur- 
rent box and all superordinate boxes), as in 
Johnson and Klein \[81. In Prolog, we use the 
binary '-' operator to separate the two mem- 
bers os the pair. 
atom(P, \[BIBs\]-\[\[PIB\] lBs\]). 
cornpose(B0s-Bls, BIs-B2s, B0s-B2s) . 
conjoin(Pl, P2, P) "- 
compose(Pl, P2, P) . 
subordinate(\[\[\] B0s\]-\[BIBIs\], 
B, B0s-Bls) . 
new index(Index C) "- 
atom(i(Index) ,C) . 
accessible index(Index, Bs Bs) "- 
member (B,Bs) , member (i (Index) ,B) . 
external( \[ \[\] \]-IS\], S) . 
The atom constructor introduces a now 
atomic proposition p,by adding it to the cur- 
rent box, i.e. the first element of the list of 
ot)en boxes. 
The compose constructor threads the dif- 
ference list representing the open boxes through 
both compose representations of the items be- 
ing composed in the same way that the com- 
pose constructor of the sets-of-infons repre- 
senlations does. The conjoin constructor is 
equivalent to the compose constructor. 
The subordinate constructor introduces 
an empty subordinate box onto the list of' cur- 
5 The grammar and file sels of infons constructors also gene.ralc 
an additional reading in which tile man that owns the donkey beats 
himself; i.e. it is taken as anaphorically dependent on every mare 
Simple extensions to tim grammar (e.g. requiring tile index of a 
pronoun to differ from the index of all c-commanding NPs) or Ihe 
semantics (e.g. requiring the gender of tile pronoun to agree with its 
antecedent's gender) would ride out this spurious analysis. 
rently open boxes. The "name" B of the sub- 
ordinate box is the list of atoms it contains. 
The new index constructor adds an atom 
of the form 2 (Index) to the semantic repre- 
sentation: no constraints are placed on Index 
(as in the sets-of-infons representation). 
The accessible index constructor is 
satisfied by a referential index Index if 
Index is introduced by new index in a 
preceding non-subordinate representation, i.e. 
if one of the superordinate boxes contains 
i (Index). 
The external (Internal, External) 
predicate initializes Internal tO have ex- 
actly one open box (empty), and returns the 
contents of that box as its external form. 
With these constructors, the parser yields 
the following semantic values for the test sen- 
tences. 
2- p( \[a,man,owns,a,donkey\], S) . 
S = \[own(X,Y) ,donkey(Y) ,i(Y , 
man(X) , i(X) \] 
This representation is tree just m case there 
are two individuals X aid }i, X is a man and 
Y is a donkey, and X owns }I. 
?- p(\[every,man,owns,a,donkey\],S) . 
S = \[ \[man (X) , i(X) \] ==> \[own (X, Y) , 
donkey(Y) ,i(Y) \] \] 
This representation is true just in case for all 
individuals X such that X is a man there is an 
individual Y such that Y is a donkey and X 
owns Y. 
2- p ( \[every, man, that, owns, a, donkey, 
beats, it\],S) . 
S = \[ \[own (X, Y) , donkey (Y) , i (Y) , man (X) , 
i (X) \] ==> \[beat (X, Y) \] \] 
This representation is true just in case for all 
individuals X and Y such that X is a man and 
Y a donkey and X owns Y, it is also true that 
X beats Y. 
Extending the Grammar to handle 
Quantifier-Raising 
In this section we sketch a syntactic ac- 
count of quantifier-raising inspired by the im- 
plementation of Cooper-storage (Cooper \[41) 
7 23 
presented in Pereira and Shieber \[12\], to which 
we refer the reader for details. Each syntactic 
constituent is associated with a list of quanti- 
tiers that are "in storage" (this corresponds in 
an LF-movement account of quantifier-scope to 
being raised out of this constituent). Quantiti- 
cational determiners add items to the quantifier 
store, and at S nodes, quantifiers are removed 
from the store and applied to the semantic 
representation. The quantitier-store of nodes 
at which quantifiers are neither added nor re- 
moved is the shuffle of the quantifier-stores of 
its children. 6. The grammar presented below 
is simply the grammar presented above with 
the addition of quantifier-storage. The lexical 
entries for this grammar are the same as the 
above, and so are not listed here. 
q(String, Analysis) "- 
external(S, Analysis), 
s(S, \[\], String, \[\]) . 
s(S,Qs) --> np(VP'SI,Qnp), vp(VP,Qvp), 
(shuffle(Qnp,Qvp,Qls) , 
apply_some (Qls, Sl, Qs, S) }. 
np(NP,Qnp) --> det(Nl'NP,Qdet), 
nl (NI,Qnl), 
{append(Qdet,Qnl,Qnp) } . 
nl(N,Qn) --> n(N,Qn) . 
nl (X^S,Qnl) --> n(X'Sl,Qn) , 
rc(X^Sl,Qrc), 
(conjoin (Sl, $2, S) , 
shuffle(Qn, Qrc,Qnl) } . 
vp(X'S,Qvp) --> v(X*VP,Qv) , 
np (vP ^S, Qnp) , 
{shuffle(Qv,Qnp,Qvp) } . 
rc(X^Sl,Qrc) --> \[that\], vp(X^Si,Qvp), 
{apply_some(Qvp, Si,Qrc,S2) } . 
np((X^Sl) ^S, \[\]) --> \[Pronoun\], 
{pronoun (Pronoun) , 
accessible index(X, Sl), 
compose(Sl, Sl,S) } . 
v(X'Y^S, \[\]) --> \[Verb\], 
\[verb (Verb,X^Y^Pred) , 
atom(Pred, S) }. 
n(X^S, \[\]) --> \[Noun\], 
{ noun (Noun, X^Pred) , 
6 Treating the quantifier-store as a syntactic feature can express many properties of LF-movement accounts, such as quantificational 
islandhood, etc., without the explicit construction of additional repre- sentations 
compose(Sl, Sl,S) , 
atom (Pred, SI) , 
new index(X,Sl) } . 
det ((X^Res) ^ (X'Scope) "Scope, 
\[Quant\]) --> \[Det\] , 
{determiner (Det, Res^Quant) } . 
The proposition shuffle (LI, LI, L3) 
is true just in case L3 is a list that can be seen 
as having been constructed in a sequence of 
steps in each of which the next available item 
is taken from either L1 or L2 and added to the 
end. So long as items remain on both L1 and 
L2, it is immaterial which of them supplies the 
next member of L3. What is important is that 
the members of L1 and L2 should all be on L3, 
and in their original order. This relationship is 
assured by the following Prolog clauses: 
shuffle(t\], \[\], \[\] ) . 
shuffle(\[QIQls\],Q2s, \[QIQ3s\]) "- 
shuffle(Qls,Qls,Q3s) . 
shuffle(Qls, \[QIQ2s\], \[QIQ3s\]) "- 
shuffle(Qls,Qls,Q3s) . 
The first clause asserts that the proposition 
is true of three empty lists, and serves to ter- 
minate the recursion implicit in the other two. 
The second clause says that, if Q2s and Q3s 
am suffixes of a pair of lists to be shuftled, and 
that shuffling them gives Qls, then the item 
that precedes Q1 s in the final result carl come 
from the first list, that is, it can be the item 
preceding Ols. The third clause says that, al- 
ternatively, the item preceding Qls can come 
from the second list. 
The grammar also makes use of the predicate 
apply_some (Quant s, OldSemant ic- 
Value, UnappliedQuant s, NewSe- 
manticValue ) 
which is true if applying zero or more quanti- 
tiers fi'om the beginning of the list Quants to a 
given OldSemanticValue yields NewSemantic- 
Value and leaves a suffix of that list of quanti- 
tiers, namely UnappliedQuants still unapplied. 
It can be defined with the following pair of 
clauses, the first of which terminates the se- 
quence of applications and the second of which 
applies the next quantifier in sequence. 
24 8 
apply_some(Qs,P,Qs,P) . 
apply_some(\[P^QpIQs\],P,QIs,PI) :- 
apply some(Qs,Qp,Qls, Pl) . 
'\]'he new grammar can be used with the 
three different semantic constructors presented 
above. Using the Predicate-Logic constructors, 
it yields results like the following: 
2- q(\[a,man, owns,a,donkey\],S) . 
S : donkey (Y) &man (X) Sown (X, Y) ; 
S =: man (X) &donkey (Y) Sown (X,Y) 
This example has two (semantically-equiva- 
lenl) representations corresponding to the two 
scope possibilities for the two existentially 
quantified NPs. 
2- q ( \[every, man, owns, a, donkey\] , S) . 
S :: donkey(Y) & man (X) ==>own (X, Y) ; 
S =: man (X) ==> (donkey (Y) &own (X, Y) ) 
In this example the two non-equivalent rep- 
resentations correspond to the two different 
scope possibilities for the quantified NPs. 
These readings paraphrase as: There is a don- 
key Y and for each man X, X owns Y and 
For each man X there is a donkey I / and X 
owns V". 
2- q ( \[every, man, that, owns, 
a,donkey,beats,it\],S) . 
S =: donkey (Y) & (man (X) &own (X, Y) ) 
:=>beat (X,Z) ; 
S =: (man(X) &donkey(Y) &own(X,Y) ) 
:=>beat (X, Z) ; 
In this example the two non-equivalent 
representations correspond to the two differ- 
enl scope possibilities for the quanti/ied NPs. 
These readings paraphrase as: There is a don- 
key Y and for each man X such that X owns 
Y it is the case that X beats Y, and "For each 
man X and donkey Y such that X owns Y, it 
is the case that X beats Y. 
Using the sets-of-infons constructors, we get 
the following results: 
2- q(\[every, man,owns,a,donkey\],S) . 
S :-: sO: \[s0:sl==>s2,s2:own(X,Y), 
sl :i (X), sl:man (X), S0 : 2 (Y), 
sO :donkey(Y)\] ; 
S = sO: \[s0:sl==>s2,s2:own(X,Y), 
s2:i(Y),s2:donkey(Y),sl:i(X), 
sl:man(X)\] 
The scope possibilities are indicated here by 
the situation in which the noun phrases are 
interpreted. The first reading displayed cor- 
responds to the quantilier-raised interpretation, 
which paraphrases as: Situation s0 contains the 
individual Y, the fact that Y is a donkey, and 
the fact that for all ways of making sl tale, s2 
is also true, where sl contains the individual 
X and the fact that X is a man, and s2 con- 
rains the fact that X owns Y. Since Y is in s(), 
under this reading it is a potential matecedent 
for ~maphors in for following sentences. 
The second reading differs from the first 
in that the NP a donkey is interpreted in the 
subordinate situation sl instead el" S0. As well 
as causing a donkey to be quantilicationally 
subordinate to every man, this also makes a 
donkey unavailable as a potential antecedent 
for anaphors in following sentences. 
We can therefore account for the fact that 
under normal intonation a donkey is interpreted 
as having wide scope over every man in the 
following discourse fiagmcnt (3). 
(3) Every man saw a donkey. It had a 
bushy tail 
We now consider one of the famous "don- 
key" sentences: 
?- q(\[every, man,that,owns,a,donkey, 
beats, it\],S) . 
S - sO: \[sO:sl==>s2,s2:beat(X,Y), 
sl:own(X,Y),sl:i(X),sl:man(X) 
sO:i(Y) ,sO:donkey(Y) \] ; 
S = sO: \[sO:sl==>s2,s2:beat(X,Y), 
sl:own(X,Y) , sl:i(Y) , sl:donkey Y) , 
sl:i (X) ,sl:man(X) \] 
The first reading displayed again corresponds 
to the quantifier-raiscd interpretation, which 
paraphrases as: Situation s0 contains an indi- 
vidual Y, and the facts that Y is a donkey and 
that every way of making S1 true also makes 
$2 tree, where S1 contains the individual X 
and the facts that X is a man and X owns Y, 
and $2 contains the fact that X beats Y. 
9 25 
Finally, the discourse-representation con- 
structors yield the following: 
2- q(\[every,man,owns,a,donkey\],S) . 
S = \[ \[i (X) , man (X) \] :=> \[own (X, Y) \] , i (Y) , 
donkey(Y)\] S = \[\[i(X),man(X)\] 
==> \[own (X, Y) , i (Y) , donkey (Y) \] \] 
These representations are direct notational 
variants of the two set-of-infons representa- 
tions of this sentence given above. The truth 
conditions of the first reading correspond to the 
wide-scope interpretation of a donkey, and can 
be paraphrased as: There is a donkey Y, and 
for every man X, X owns !/. 
?- q(\[every, man,that,owns,a,donkey, 
beats, it\] ,S) . 
S = \[ \[own (X, Y) , i (X) ,man(X) \] 
=:>\[beat (X,Y) \] ,i(Y) ,donkey(Y) \] ; 
S = \[\[own(X,Y),i(Y),donkey(Y),i(X), 
man (X) \] ==> \[beat (X, Y) \] \] 
Again, these representations are direct nota- 
tional variants of the two sets-of-infons repre- 
sentations of this sentence given above. The 
truth conditions of the first reading correspond 
to the wide-scope interpretation of a donkey, 
and can be paraphrased as: There is a donkey 
Y, and for every man X such that X owns Y, 
X beats I/. 
The same correlation between quantifica- 
tional scope and anaphoric scope holds with 
these constructors, as expected. 
Conclusion 
We have worked out a scheme lot comput- 
ing the logical lorms of sentences incremen- 
tally in the course of parsing them which we 
believe achieves an unprecedented level of ab- 
straction of the semantic from the syntactic 
parts of the grammar. The very incrementality 
of the scheme might be used to argue against it. 
Given the prevalence of scope ambiguities, the 
interests of computational efficiency may be 
best served by a scheme that delays all seman- 
tic computation until the parsing is complete 
so as not to work unnecessarily on phrases that 
turn out not to be capable of incorporation in a 
complete analysis of the sentence. Hobbs and 
Sheiber \[7\] adopt such a scheme apparently on 
the grounds of greater perspicuity. In any case, 
the modifications that need to be made to our 
scheme are entirely trivial, requiring only the 
introduction of a modest amount of symbolic 
computation. Basically, the idea is to use oper- 
ations which, instead of returning pieces of the 
final logical form incrementally and nondeter- 
ministically, return expression that will exhibit 
this nondeterministic behavior when evaluated 
later. The later evaluation will, of course, be as 
specified be the detinitions we have given. In 
short, we believe that the abstractions we have 
created effectively isolate the syntactk" rules 
both from the corresponding semantic formal- 
ism and from the architecture of the system by 
which both of them will be interpreted. 

Bibliography 

\[1\] Abramson, H., and Dahl, V. Logic Gram- 
mars. Springer Verlag, New York, 1989. 

1211 Barwise, J., and Perry, J. Situations and At- 
titudes. Bradford Books/MIT Press, Cam- 
bridge, Massachusetts, 1983. 

\[3\] Colmerauer, A. An interesting subset of 
natural language. In Logic Programming, 
K. L. Clark and S.-A. Tarnlund, Eds. 
Academic Press, New York, 1982. 

\[4\] Cooper, R. Quantification and Syntactic 
Theory, vol. 21 of Synthese Language 
Library. D. Reidd, Dordrecht, 1983. 

\[5\] Davidson, D. The logical form of ac- 
tion sentences. In The Logic of Decision 
and Action, N. Rescher, Ed. University of 
Pittsburgh Press, Pittsburgh. Pennsylvania, 
1967. 

\[16\] Fenstad, J. E., et al. Situations, Language 
and Logic. Reidel, Dordrecht, 1987. 

\[7\] Hobbs, J. R., and Shieber, S. M. An al- 
gorithm for generating quantifier scopings. 
Computational Linguistics 13, 1-2, 47-63. 

\[8\] Johnson, M., and Klein, E. Discourse, 
anaphora and parsing. In Coling 88 (Bonn, 
West Germany, 1986). 
26 i0 

\[9\] Kamp, H. A theory of truth and semantic 
representation. In Formal Methods in the 
Study of Language, J. A. G. Groenendijk, 
T. M. V. Janssen, and M. B. J. Stokhof, 
Eds., vol. 136. Mathematical Centre Tracts, 
Amsterdam, 1981, pp. 277-322. 

\[10\]Karttunen, L. Discourse referents. In Syn- 
tax and Semantics, 7, J. McCawley, Ed. 
Academic Press, New York, 1976, pp. 363- 
385. 

\[ll\]McCord, M. C. Focalizers, the scoping 
problem, and semantic interpretation rules 
in logic grammars. In Logic Programming 
and Its At)plications. Ablex, New Jersey, 
1986. 

\[12\]Pereira, F. C. N., and Shieber, S. M. Prolog 
and Natural Language Analysis, vol. 10 
of C.S.L.I. Lecture Notes Series. Chicago 
University Press, Chicago, 1987. 

\[13\]Thomason, R. Formal Philosophy. Se- 
lected Papers of Richard Montague. Yale 
University Press, New Haven, Connecti- 
cut, 1974. 
