Pluralities in Semantics
(part 2)

posted by Darryl on 12 Dec 2014

I ended the previous post by suggesting that a set-based approach to pluralities, as in

[[John and Susan lifted the grate]] = lifted({john,susan}, {crate})

would not work well for at least two reasons:

Firstly, sentences like "John lifted the crate with Susan" should mean more or less the same thing as "John and Susan lifted the crate" on the collective-lifting reading, but there is no single noun phrase that has both John and Susan, so we would need some really rather fancy way to get that single set from two distinct noun phrases.

And secondly, we want to store these predicates — stabbed, spoke, lifted, surrounded — in a database, we would need to have compound data columns, which can be rather nasty since these sets can be arbitrarily large. Logically it's no problem, but computationally it's a bit of a mess to have that.

The task is to present an alternative representation that doesn't have these problems. But before I can do that, we need to detour a little bit to discuss adverbial modification, which I will do in this post. In the following brief discussion, I will revert to a set-free framework, since that's where we're headed anyway.

Consider the sentence "Stephen drank coffee". We've been assuming that the meaning of this should look something like

drank(stephen,coffee)

but what if we added an adverbial, such as "today", to produce the sentence "Stephen drank coffee today"? We need a way to express what this means. The simple option is to say there's some kind of propositional operator — some predicate that takes propositions as arguments, such as &. For instance, we might propose this:

time(drank(stephen,coffee), today)

This option really isn't very good tho: there are inferences we can make that this sentence just doesn't support right now. For instance, if we know "Stephen drank coffee today" then we're allowed to conclude "Stephen drank coffee", but no rule of logic that we're currently using says that if we know

time(drank(stephen,coffee), today)

then we're allowed to conclude

drank(stephen,coffee)

If we wanted to make this inference possible, we would need to add a new rule of logic, such as

if you know
  time(X,Y)
then you may know
  X

This approach would be some kind of modal logic of time (normally called a temporal logic).

Furthermore, there seems to now be some kind of redundancy between the past tense that the predicate is encoding, and the time operator. We can of course factor tense out into a second use of time operator like so:

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

and then probably also add another rule of logic that lets us permute nested time operators, as in

if you know
  time(time(X,Y), Z)
then you may know
  time(time(X,Z), Y)

But this isn't the end of the trouble with that sort of approach to adverbials, because time isn't the only kind of adverbial we have, there's frequency ("Delenn reads Universe Today once a day"), place ("Michael works in Security"), direction ("G'Kar glared at Londo"), manner ("Lennier flew wrecklessly"), plus many many others. As the number of kinds of adverbials grows, the number of new operators and inference rules grows, but not linearly: if there are n adverbial operators, the number of inference rules (primarily for permutations) will be proportional to n!, so we get a combinatorial explosion.

The standard solution to this was introduced by Donald Davidson: events! Rather than assuming "Stephen drank coffee" means something like

drank(stephen,coffee)

We introduce a new argument, called an event, like so:

drank(e,stephen,coffee)

This can be viewed as nothing more than a formal trick, but a better attitude is to view events as the name suggests: the event or action that takes place. If Stephen drank coffee twice, there would be two events of coffee drinking, and so different arguments for each event:

drank(e0,stephen,coffee) & drank(e1,stephen,coffee)

Once we have events, it becomes easy to capture the adverbial facts: adverbial modifiers are predicates of events just like verbs are! 1

[[Stephen drank coffee today]] = drank(e,stephen,coffee) & time(e,today)

(or even with tense split off:)

[[Stephen drank coffee today]]
  = drink(e,stephen,coffee) & time(e,past) & time(e,today)

Once you make this change, the inferences that we were worried about come for free from the inference rules of conjunction. From the meaning of "Stephen drank coffee today" we can easy conclude "Stephen drank coffee", because from

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

we can easily conclude

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

When it doubt, try using a new argument, and conjunction!

In the next post in this series, we'll take this approach even further, and in doing so, come up with a way to account for the properties of plural noun phrases that were so puzzling before.

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.

Notes

1 At this point, you may be inclined to suggest that we add an argument for moments in time, as well, so that we can assign to "Stephen drank coffee today" the meaning

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

This inclination would be exactly the right thing to do. Aside from the weirdness of having "past" and "today" as arguments to a time predicate, there're also good empirical reason to do this. Sentences such as "Stephen drank coffee before he went to Medlab" demonstrate that we can order events by time, and simply having a time predicate like before is insufficient. What we'd really like is to have two events, with two times, which are ordered:

drink(e0,stephen,coffee) & time(e0,t0) & past(t0)
& goto(e1,stephen,medlab) & time(e1,t1) & past(t1)
& t0 < t1