Pluralities in Semantics
(part 3)

posted by Darryl on 14 Dec 2014

As promised last time, we can now tackle the problem of representing pluralities. Once we have events and adverbial modifiers separated off as in

drink(e,stephen,coffee) & time(e,past) & time(e,today)

it becomes relatively trivial to propose that we do the very same thing to the arguments of verb predicates, as well. There are a number of alternative ways to do this, but one option is to have special relations associated with the predicate. So for instance, instead of


we might instead represent this meaning as

drink(e) & drinker(e,stephen) & drinkee(e,coffee)

This approach is called "thematic separation" (the roles of drinker and drinkee are called "thematic roles" for historical reasons), and was proposed by Héctor-Neri Castañeda. Semantics that employs thematic separation is often called "neo-Davidsonian" because its an updated version of Davidson's original event semantics.

Let's consider again the example of "John and Susan lifted the crate", on the one reading where they lifted the crate together because it would be too heavy for either of them alone. With this new approach to event participants, we can give this sentence the meaning

lift(e) & lifter(e,john) & lifter(e,susan) & liftee(e,crate)

The fact that they are both engaged in the very same act of lifting, rather than distinct acts, is captured by the reuse of the same event. The possibility of expressing this situation with sentences like "John lifted the crate with Susan" is easily captured now, because each participant can be connected with the event independently: the subject "John" contributes


while the adverbial "with Susan" contributes


Because there's no set of participants, as in the original flawed proposal, there's no mystery how both of these noun phrases can contribute to the same participant role in this sort of event.

But I also mentioned sentences such as "the Starfuries surrounded the vessel", which very strongly push us towards a collective interpretation. It would be weird, tho certainly not logically impossible, to say that each of the Starfuries surrounded the vessel, since Starfuries are pretty small. What we envision is that the Starfuries are positioned in such a way that the vessel can't escape. Again we can assign a meaning to this relatively easily using the neo-Davidsonian method:

& surrounder(e,sf0) & surrounder(e,sf1) & surrounder(e,sf2)
& surroundee(e,vessel)

But why doesn't this entail that any given Starfury surrounded the vessel on its own? After all, we can use our rules for conjunction to conclude

surround(e) & surrounder(e,sf0) & surroundee(e,vessel)

At this point we can simply defer to the primitive meaning of the predicate surround, defining it to be true under precisely the conditions we need, and no others:

surround(e) is true if and only if ...
  there is some appropriately shaped region r such that for all x such that surrounder(e,x), x is in region r, and for all y such that surroundee(e,y), y is inside region r, and ...

That is to say, it is what it means to be an event of surrounding, rather than some incidental representational property of the logic, that determines that the Starfuries are all required to participate together, and do not do so individually (at least not without being massive, and thereby actually filling the surrounding region).

This approach places the burden of collective participation on the words/predicates themselves, and makes it much easier to defer such judgments to non-representation-related systems (such as mental modules, or in the case of Language Engine, to plugins responsible for different kinds of domain knowledge). The semantics no longer knows nor cares about pluralities, even if pluralities matter to meaning, and thats ok.

We can also now see how this makes it trivial to store these representations of meanings in a table-based database. We simple need to have a table for participant role information. Each row represents one fact such as surrounder(e,sf0), like so:

role       | event | participant
...        | ...   | ...
surrounder | e     | sf0
surrounder | e     | sf1
surrounder | e     | sf2
surroundee | e     | vessel
...        | ...   | ...

An interesting and important property of this approach, incidentally, is that there are no higher-order pluralities in the representation — no sets within sets, etc. For databases this is especially good, because not only do we not have to worry about field entries that are arbitrary in length, but we also can avoid entries of arbitrary depth. Another interesting consequence is that the logic required to represent these meanings can remain first-order, which lets us use much more efficient algorithms than higher-order logics require. Even if we chose to use sets at the meta level, the meanings themselves are devoid of sets and can never make reference to them.

If you have comments or questions, get it touch. I'm @psygnisfive on Twitter, augur on freenode (in #languagengine and #haskell). Here's the HN thread if you prefer that mode, and also the Reddit threads.