17.2.1 Predicate-Argument Structure

Human languages have a form of predicate-argument arrangement at the core of their semantic structure. To a first approximation, this predicate-argument structure asserts that specific relationships, or dependencies, hold among the various concepts underlying the constituent words and phrases that make up sentences. It is this underlying structure that permits the creation of a single composite meaning

representation from the meanings of the various parts of an input. One of the most important jobs of a grammar is to help organize this predicate-argument structure. Correspondingly, it is critical that our meaning representation languages support the predicate-argument structures presented to us by language.

We have already seen the beginnings of this concept in our discussion of verb complements in Chs. 11 and 15. There we saw that verbs dictate specific constraints on the number, grammatical category, and location of the phrases that are expected to accompany them in syntactic structures. To briefly review this idea, consider the following examples:

(17.12) I want Italian food.

(17.13) I want to spend less than five dollars.

(17.14) I want it to be close by here.

These examples can be classified as having one of the following three syntactic argument frames:

NP want Inf-VP

NP want NP

NP want NP Inf-VP

These syntactic frames specify the number, position and syntactic category of the arguments that are expected to accompany a verb. For example, the frame for the variety of want that appears in example (17.12) specifies the following facts:

• There are two arguments to this predicate.

Both arguments must be NPs.

• The first argument is pre-verbal and plays the role of the subject.

• The second argument is post-verbal and plays the role of the direct object.

As we have shown in previous chapters, this kind of information is quite valuable in capturing a variety of important facts about syntax. By analyzing easily observable semantic information associated with these frames, we can also gain considerable insight into our meaning representations. We will begin by considering two extensions of these frames into the semantic realm: semantic roles and semantic restrictions on these roles.

The notion of a semantic role can be understood by looking at the similarities among the arguments in examples (17.12) through (17.14). In each of these cases, the pre-verbal argument always plays the role of the entity doing the wanting, while the post-verbal argument plays the role of the concept that is wanted. By noticing these regularities and labeling them accordingly, we can associate the surface arguments of a verb with a set of discrete roles in its underlying semantics.

More generally, we can say that verb subcategorization frames allow the linking of

arguments in the surface structure with the semantic roles these arguments play in the underlying semantic representation of an input. The study of roles associated with specific verbs and across classes of verbs is usually referred to as thematic role or case role analysis and will be studied more fully in Ch. 19.

The notion of semantic restrictions arises directly from these semantic roles. Returning to examples 17.12 through 17.14, we can see that it is not merely the case that each initial noun phrase argument will be the wanter but that only certain kinds, or categories, of concepts can play the role of wanter in any straightforward manner. Specifically, want restricts the constituents appearing as the first argument to those whose underlying concepts can actually partake in a wanting. Traditionally, this notion is referred to as a selectional restriction. Through the use of these selectional restrictions, verbs can specify semantic restrictions on their arguments.

Before leaving this topic, we should note that verbs are by no means the only objects in a grammar that can carry a predicate-argument structure. Consider the following phrases from the BERP corpus:

(17.15) an Italian restaurant under fifteen dollars

In this example, the meaning representation associated with the preposition under can be seen as having something like the following structure:

Under(ItalianRestaurant, $15)

In other words, prepositions can be characterized as two-argument predicates where the first argument is an object that is being placed in some relation to the second argument.

Another non-verb based predicate-argument structure is illustrated in the following example:

Make a reservation for this evening for a table for two persons at 8.

Here, the predicate-argument structure is based on the concept underlying the noun reservation, rather than make, the main verb in the phrase. This example gives rise to a four argument predicate structure like the following:

Reservation(Hearer, Today, 8PM, 2)

This discussion makes it clear that any useful meaning representation language must be organized in a way that supports the specification of semantic predicate-argument structures. Specifically, it must include support for the kind of semantic information that languages present:

• variable arity predicate-argument structures

• the semantic labeling of arguments to predicates

• the statement of semantic constraints on the fillers of argument roles

17.3 MODEL-THEORETIC SEMANTICS

The last two sections focused on various desiderata for meaning representations and on some of the ways in which natural languages convey meaning. We haven't said much formally about what it is about meaning representation languages that allows them to do all the things we want them to. In particular, we might like to have some kind of guarantee that these representations can do the work that we require of them: bridge the gap from merely formal representations to representations that tell us something about some state of affairs in the world.

To see how we might provide such a guarantee, let's start with the basic notions shared by most meaning representation schemes. What they all have in common is the ability to represent objects, properties of objects and relations among objects. This point of view can be formalized via the notion of a model. The basic idea is that a model is a formal construct that stands for the particular state of affairs in the world that we're trying to represent. Expressions in a meaning representation language will then be mapped in a systematic way to the elements of the model. If the model accurately captures the facts we're interested in concerning some state of affairs in the world, then a systematic mapping between the meaning representation and model provides the necessary bridge between the meaning representation and world being considered. As we'll see, models provide a surprisingly simple and powerful way to ground the expressions in meaning representation languages.

Before we start let's introduce some terminology. The vocabulary of a meaning representation consists of two parts: the non-logical vocabulary and the logical vocabulary. The non-logical vocabulary consists of the open-ended set of names for the objects, properties and relations that make up the world we're trying to represent. These appear in various schemes as predicates, nodes, labels on links, or labels in slots in frames. The logical vocabulary consists of the closed set of symbols, operators, quantifiers, links, etc. that provide the formal means for composing expressions in a given meaning representation language.

We’ll start by requiring that each element of the non-logical vocabulary of a meaning representation have a \textit{denotation} in the model. By denotation, we simply mean that every element of the non-logical vocabulary corresponds to a fixed well-defined part of the model. Let’s start with objects, the most basic notion in most representational schemes. The \textit{domain} of a model is simply the set of objects that are part of the application, or state of affairs, being represented. Each distinct concept, category or individual in an application denotes a unique element in the domain. A domain is therefore formally a set. Note that it isn’t the case that every element of the domain has a corresponding concept in our meaning representation; it’s perfectly acceptable to have domain elements that aren’t mentioned or

conceived of in the meaning representation. Nor do we require that elements of the domain have a single denoting concept in the meaning representation; a given element in the domain might have several distinct representations denoting it, such as Mary, WifeOf(Abe), or MotherOf(Robert).

We can capture properties of objects in a model by denoting those domain elements that have the property in question; that is, properties denote sets. Similarly, relations among objects denote sets of ordered lists, or tuples, of domain elements that take part in the corresponding relations. This approach to properties and relations is thus an \textit{extensional} one; the denotation of properties like red is the set of things we think are red, the denotation of a relation like Married is simply the set of pairs of domain elements that are married. To summarize:

• Objects denote elements of the domain

• Properties denote sets of elements of the domain

• Relations denote sets of tuples of elements of the domain

There is one additional element that we need to make this scheme work. We need a mapping that systematically gets us from our meaning representation to the corresponding denotations. More formally, we need a function that maps from the non-logical vocabulary of our meaning representation to the proper denotations in the model. We'll call such a mapping an interpretation.

To make these notions more concrete, let's return to the realm of restaurants we introduced in Ch. 4. Assume that our application concerns a particular set of restaurant patrons and restaurants, various facts about the likes and dislikes of the patrons, and facts about the restaurants such as their cuisine, typical cost, and noise level.

To begin populating our domain, D, let's assume that in the current state of affairs we're dealing with four patrons designated by the non-logical symbols Matthew, Franco, Katie and Caroline. These four symbols will denote 4 unique domain elements. We'll use the constants a, b, c and, d to stand for these domain elements. Note that we're deliberately using meaningless, non-mnemonic names for our domain elements to emphasize the fact that whatever it is that we know about these entities has to come from the formal properties of the model and not from the names of the symbols. Continuing, let's assume that our application includes three restaurants, designated as Frasca, Med and Rio in our meaning representation, that denote the domain elements e, f and g. Finally, let's assume that we're dealing with the three cuisines Italian, Mexican, and Eclectic, denoting i, j, and k in our model.

Having populated the domain, let's move on to the properties and relations we believe to be true in this particular state of affairs. Let's assume that in our application we need to represent some properties of restaurants such as the fact that

| Domain\nMatthew, Franco, Katie and Caroline\nFrasca, Med, Rio\nItalianCuisine, MexicanCuisine, EclecticCuisine | $ \mathcal{D} = \{a, b, c, d, e, f, g, h, i, j\} $\na, b, c, d\ne, f, g\nh, i, j |

| --- | --- |

| Noisy\nFrasca, Med and Rio are noisy | Noisy = \{e, f, g\} |

| Likes\nMatthew likes the Med\nKatie likes the Med and Rio\nFranco likes Frasca\nCaroline likes the Med and Rio | Likes = \{(a, f), (c, f), (d, e), (b, c), (d, f), (e, g)\}, (d, g) \} |

| Serves\nMed serves eclectic\nRio serves Mexican\nFrasca serves Italian | Serves = \{(e, j), (d, f, i), (e, h)\} |

some are noisy or expensive. Properties like Noisy denote the subset of restaurants from our domain that are known to be noisy. Two-place relational notions, such as which restaurants individual patrons Like, denote ordered pairs, or tuples, of the objects from the domain. Similarly, since we decided to represent cuisines as objects in our model, we can also capture which restaurants Serve which cuisines as a set of tuples. One particular state of affairs using this scheme is given in Fig. 17.2.

Given this simple scheme, we can ground the meaning of pretty much any of the representations shown earlier in Fig. ?? by simply consulting the appropriate denotations in the corresponding model. A representation claiming, for example, that Matthew likes the Rio, or that the The Med serves Italian can be evaluated by mapping the objects in the meaning representations to their corresponding domain elements, and any links, predicates, or slots in the meaning representation to the appropriate relations in the model. More concretely, a representation asserting that Matthew likes Frasca can be verified by first using our interpretation function to map the symbol Matthew to its denotation a, Frasca to e, and the Likes relation to the appropriate set of tuples. We then simply check that set of tuples for the presence of the tuple $ \langle a,e\rangle $. If, as it is in this case, the tuple is present in the model

then we can conclude that Matthew likes Frasca is true, and if it isn't we can't.

This is all pretty much straightforward, we're simply using sets and operations on sets to ground the expressions in our meaning representations. Of course, the more interesting part comes when we consider more complex examples such as the following:

(17.17) Katie likes the Rio and Matthew likes the Med.

(17.18) Katie and Caroline like the same restaurants.

(17.19) Franco likes noisy, expensive restaurants.

(17.20) Not everybody likes Frasca.

Clearly, our simple scheme for grounding the meaning of representations is not adequate for examples such as these. Plausible meaning representations for these examples will not map directly to individual entities, properties or relations. Instead, they involve complications such as conjunctions, equality, quantified variables and negations. To assess whether or not these statements are consistent with our model we'll have to tear them apart, assess the parts and then determine the meaning of the whole from the meaning of the parts according to the details of how the whole is assembled.

Consider the first example given above. A typical meaning representation for examples like this will include two distinct propositions expressing the individual patron's preferences, conjoined with some kind of implicit or explicit conjunction operator. Obviously, our model doesn't have a relation that encodes the pairwise preferences for all of the patrons and restaurants in our model, nor does it need to. We know from our model that Matthew likes the Med and separately that Katie likes the Rio (that is, we know that the tuples $ \langle a, f \rangle $ and $ \langle c, g \rangle $ are members of the set denoted by the Likes relation.) All we really need to know is how to deal with the semantics of the conjunction operator. If we assume the simplest possible semantics for the English word and, the whole statement is true if it is the case each of the components is true in our model. In this case, both components are true since the appropriate tuples are present and therefore the sentence as a whole is true.

What we’ve done implicitly in this example is to provide what is called a truth-conditional semantics for the assumed conjunction operator in some meaning representation. That is, we’ve provided a method for determining the truth of a complex expression from the meanings of the parts (by consulting a model) and the meaning of an operator by essentially consulting a truth-table. The various representations that populate Fig. 17.1 are truth-conditional to the extent that they give a formal specification as to how we can assess the meaning of complex sentences from the meaning of their parts. In particular, we’ll need to know the semantics of the entire logical vocabulary of the meaning representation scheme being used.

Note that although the details of how this happens is dependent on details of the particular meaning representation being used, it should be clear that assessing the truth conditions of examples like these involves nothing beyond the simple set operations we've been discussing. We'll return to these issues in the next section where we discuss them in the context of the semantics of First Order Logic.

17.4 FIRST-ORDER LOGIC

First-Order Logic (FOL) is a flexible, well-understood, and computationally tractable approach to the representation of knowledge that satisfies many of the desiderata given in Sections 17.1 and 17.2 for a meaning representation language. Specifically, it provides a sound computational basis for the verifiability, inference, and expressiveness requirements, and as we'll see a sound model-theoretic semantics.

However, the most attractive feature of FOL is the fact that it makes very few specific commitments as to how things ought to be represented. As we will see, the specific commitments it does make are ones that are fairly easy to live with and are shared by many of the schemes mentioned earlier; the represented world consists of objects, properties of objects, and relations among objects.

The remainder of this section first provides an introduction to the basic syntax and semantics of FOPC, and then describes the application of FOPC to a number of linguistically relevant topics. Section 17.7 then discusses the connections between FOPC and some of the other representations shown earlier in Figure 17.1.