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 written in a form which, by abstracting away from details of the 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.. The basis of our proposal is that each grammatical rule should contain, or be paired with, an expres­sion written in terms of semantic 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 mem­bers corresponding to such notions as compo­sition, conjunction, etc. The set is small and in­dependent of the semantic formalism. The op­erations arc 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 constaictors here, which we have dubbed the predicate-logic, the sets-of-infons and the discourse-representation 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 arc rel­evant to all semantic theories and those not needed for a particular one arc given degen­erate definitions. The simplest kind of con­struction operator is the identity function which maps every input i onto just one output, namely i.

The operators arc the following:

The grammar generates simple transitive clauses and subject-relative clauses that do not 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-dcpcndcncics, etc., presented there could also be incorporated without difficulty.

:- op (950, xfy, " ) .

:- op(300, xfx, - ->) .

pa r s o ( S t. r j n g , Ext Sem) : -external(Int Sem,KxtSem) , s(]ntScm,String,[)> .

s (S) —> np(VP"5), vp (VP) . np(NP) —> det(Nl"NP), ni(NI), ni (N) --> n (N) .

{conjoin(SI,S2,S) ) . vp(X"S) --> v(X"VP), np(VP"S). rc(VP) —> [that], vp(VP).

{ determiner ( Dot:, Res"Scope"S) } . np((X"Sl)"S) —> [Pronoun], {pronoun (Pronoun), accessible index(X,S2), compose(S1,S2,S) }.

pronoun(he). pronoun(she). pronoun(him). pronoun(he r) . pr onoun (it.) .

verb (likes, X"Y"likes(X,Y)). verb(saw, X"Y"see(X,Y)). verbfbeats, X"Y"beat(X,Y)). verb(owns, X"Y"own(X,Y).

noun (woman, X"worr.an (X) ) .

noun(man, X"man(X)).

noun(donkey, X"donkey(X) ) .

con join(Res,Scope,S) . determiner(every, subordinate(Res, ResName, SI), subordinate(Scope, ScopeName, Resl), atom(ResName ==> ScopeName, S2).

Most of the grammar should be familiar, even if it is somewhat more pedantically expressed than is usual. Following Pereira and Shicbcr (who were in turn inspired by Montague), VP and N meanings arc 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 cquivalcntly, (x~S0)~S), where VP represents a VP meaning, X a referential index, and S and SO represent S meanings.

All manipulation of semantic values is per­formed by constructor primitives, rather than by explicit construction of terms. For exam­ple, the Nl production that introduces relative-clauses invokes conjoin explicitly to conjoin the semantic values of the N and the relative clause to yield the semantic value of the Nl. The sharing of the referential index X between 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 Pred associ­ated with the lexical meaning of the noun. S2 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 SO, and speci­fies that the S component is the composition of SO and the SO component of the VP mean­ing. (Recall that the semantic representations of pronouns, like all NP's, arc terms of the 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­terminer's restriction, which defines the enti­ties that the quantification ranges over, and its scope, the component of the expression quan­tified over. (2) indicates the components of the utterance corresponding to the restriction and the scope of the quantifier every in the absence of quantifier-raising.

(2) Every man that saw a donkey kicked it.

Restrictor Scope

The grammars presented here identify the re­strictor and the scope of a determiner in the syntax; e.g. quantifier-raising arises from the grammar permitting multiple assignments 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'Scope'Sentence, where Res 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 the implication operator in semantic represen­tations (sec Pereira and Shicbcr [12]).

(3) determiner(every, R es "Scope "(R es==> Scope)).

This lexical entry docs 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 cither the restriction or scope of the quantifi­cational expression. 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 SI and S2, where S2 is the semantic atom ResName ==> Scope-Name. Res is subordinate to SI, and is itself the composition of ResO and Re si, where ResO is the semantic representation of the re­strictor. 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 arc depicted by vertical lines (the name of the subordinate space is written alongside the line), and compo­sition relationships arc indicated by V-shaped diagonals.

These constructors build a predicate-logic type of semantic representation in a fairly transparent fashion. Pronouns are treated as free variables, there are no constraints on their distribution, and anaphoric binding is not

Scope ScopeName ResO Resl

ResName ==> ScopeName SI S2 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 repre­senting it:

atom(Prop, Prop).

The conjunction of P and Q is represented by the term P&Q.

conjoin (P,P,P&Q) .

There are no constraints on new indices.

There arc no constraints on accessible indices.

accessible_index (__, _) .

Sequencing is unimportant.

compose(P,P,P).

A Subordinate space can be introduced freely.

subordinate (__, Sub, Sub) .

Internal and external forms arc identical.

external (P,P) .

The grammar described above and the predicate-logic constructors yield analyses such as the following:

Roughly this latter form might be interpreted as: if X is a man and F is a donkey and X owns Y, then there is a Z such that X beats Z.

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 constructor). This entails that the internal form of these semantic representations encode infor­mation about preceding representations. Both constructors thread this information using the difference-list technique described in |8j.

The primitive clement of the sets-of-infons representation is inspired by the infons of Situ­ation Semantics [2]. 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 sO : sleep (kim). For simplicity arbitrar­ily named constants (like the gensyms of Lisp) arc used as the names of situations in this rep­resentation: this has the disadvantage that the definitions of the external and subordinate con­structors are not dcclarativcly specified.

The internal form of a sets of infons rep­resentation has three components. We repre­sent them in Prolog with a term of the form @(Sits, Infonsln, InfonsOut). The first is a slack whose top element is the situa­tion currently being defined, and whose other elements arc 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 of infons introduced in preceding representa­tions with the addition any infons added to the representation by the semantic representation constructor. In describing the term @ (Sits, Infonln, InfonsOut ), we use the names Infons In and InfonsOut to stress the fact that they constitute a difference list.

: - op( 900, xfx, : ) .

member(Sit :i(Index),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 Infonsln 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 constructor is

The predicate member used here, and elsewhere in this paper, has its standard logical definition: viz: member (X, [X ! _] ) . membGr(X, {_, I,]) :- member(X, L) . If this definition is

satisfied for a referential index Index if Index was introduced by new_index to 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 constaictors are used with the grammar defined above, the following analyses are obtained:

This can be paraphrased as: Situation 50 con­tains individuals X and Y; in sO X is a man, Y is a donkey and X owns Y.

This can be paraphrased as: Situation sO con­tains the fact that all situations of type si are also situations of type s'2. A situation is of type si 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,

This can be paraphrased as: Situation sQ contains the fact that all situations of type si are also situations of type s2. A situation is of type si if it contains individuals X and Y, X

used with the grammars and constructors given in this paper, the SLD selection rule of Prolog may lead to non-termination. It is in general necessary to delay the evaluation of the member predicate until its second argument is instantiated, which can be done using the freeze primitive of Prolog II.

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 [8]. In Prolog, we use the binary '-' operator to separate the two mem­bers os the pair.

member(B,Bs), member(i (Index) ,B) . external ([[]]- [S] , S) .

The atom constructor introduces a new atomic proposition P.by adding it to the cur­rent box, i.e. the first clement of the list of open 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­sentations docs. The conjoin constructor is equivalent to the compose constructor.

The subordinate constructor introduces an empty subordinate box onto the list of cur-

The grammar and the sets of infons constructors also generate an additional reading in which die man that owns the donkey beats himself; i.e. it is taken as anaphorically dependent on every man. Simple extensions to die grammar (e.g. requiring the index of a pronoun to differ from the index of all c-commanding Nl's) or the semantics (e.g. requiring the gender of the pronoun to agree with its antecedent's gender) would rule 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 i (Index) to the semantic repre­sentation: no constraints arc 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.

This representation is true just in case there are two individuals X and Y, X is a man and Y is a donkey, and X owns 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.

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.

In this section we sketch a syntactic ac­count of quantifier-raising inspired by the im­plementation of Cooper-storage (Cooper [4]) presented in Pereira and Shieber [12], to which we refer the reader for details. Each syntactic constituent is associated with a list of quanti­fiers that are "in storage" (this corresponds in an LF-movement account of quantifier-scope to being raised out of this constituent). Quantifi­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 quantifier-store of nodes at which quantifiers are neither added nor re­moved is the shuffle of the quantifier-stores of its children.. The grammar presented below is simply the grammar presented above with the addition of quantifier-storage. The lexical entries for this grammar arc the same as the above, and so are not listed here.

compose(SI, S2, S) , atom(Pred,SI) , new_index(X,S2)). det((X'Res)"(X'Scope)'Scope, [Quant]) --> [Det], {determiner(Det, Res'Quant)].

The proposition shuffle (LI, L2, 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 LI or L2 and added to the end. So long as items remain on both LI and L2, it is immaterial which of them supplies the next member of L3. What is important is that the members of LI and L2 should all be on L3, and in their original order. This relationship is assured by the following Prolog clauses:

shuffle([],[],[]).

shuffle(Qls,Q2s,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 arc suffixes of a pair of lists to be shuffled, and that shuffling them gives Qls, then the item that precedes Qls in the final result can come from the first list, that is, it can be the item preceding Qls. 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(Quants, OldSemantic-Value, UnappliedQuants, NewSe-manticValue)

which is true if applying zero or more quanti­fiers from the beginning of the list Quants to a given OldSemanticValue yields NewSemantic-Value and leaves a suffix of that list of quanti­fiers, 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.

We have worked out a scheme for comput­ing the logical forms 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

Sheibcr [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 nondctcr-ministically, return expression that will exhibit this nondelcrministic behavior when evaluated later. The later evaluation will, of course, be as specified be the definitions we have given. In short, we believe that the abstractions we have created effectively isolate the syntactic rules both from the corresponding semantic formal­ism and from the architecture of the system by which both of them will be interpreted.

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

[2] Barwisc, J., and Perry, J. Situations and At­titudes. Bradford Books/MIT Press, Cam­bridge, Massachusetts, 1983.

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

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

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

[6] Fenstad, J. E., et al. Situations, Language and Logic. Rcidel, Dordrecht, 1987.

[7] Hobbs, J. R., and Shiebcr, 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).