GSV are interested in developing and establishing a reasonable theory
of discourse update. One way of looking at this paper is like this:
- GSV = GS + V
+ GSV = GS + V, where
- GS = Dynamic Predicate Logic L&P 1991: dynamic binding, donkey anaphora
+ GS = Dynamic theories of binding of Groenendijk and Stokhof, e.g.,
+ Dynamic Predicate Logic L&P 1991: dynamic binding, donkey anaphora
Dynamic Montague Grammar 1990: generalized quantifiers, discourse referents
- V = epistemic modality
+ V = a dynamic theory of epistemic modality, e.g.,
+ Veltman, Frank. "Data semantics."
+ In Truth, Interpretation and Information, Foris, Dordrecht (1984): 43-63.
That is, Groenendijk and Stokhof have a well-known theory of dynamic
semantics, and Veltman has a well-known theory of epistemic modality,
theoretical level, these scholars are proposing a strategy for
managing the connection between variables and the objects they
designate in way that is flexible enough to be useful for describing
-natural language. The main way they attempt to do this is by
-inserting an extra level in between the variable and the object:
-instead of having an assignment function that maps variables directly
-onto objects, GSV provide *pegs*: variables map onto pegs, and pegs
-map onto objects. We'll discuss in considerable detail what pegs
-allow us to do, since it is highly relevant to one of the main
-applications of the course, namely, reference and coreference.
+natural language.
-What are pegs? The term harks back to a paper by Landman called `Pegs
-and Alecs'. There pegs are simply hooks for hanging properties on.
-Pegs are supposed to be as anonymous as possible. Think of hanging
-your coat on a physical peg: you don't care which peg it is, only that
-there are enough pegs for everyone's coat to hang from. Likewise, for
-the pegs of GSV, all that matters is that there are enough of them.
-(Incidentally, there is nothing in Gronendijk and Stokhof's original
-DPL paper that corresponds naturally to pegs; but in their Dynamic
-Montague Grammar paper, pegs serve a purpose similar to discourse
-referents there, though the connection is not simple.)
-
-On an engineering level, the fact that GSV are combining anaphora and
-bound quantification with epistemic quantification means that they are
-gluing together related but distinct subsystems into a single
-fragment. These subsystems naturally cleave into separate layers in a
-way that is obscured in the paper. We will argue in detail that
-re-engineering GSV using monads will lead to a cleaner system that
-does all of the same theoretical work.
-
-Empirical targets: on the anaphoric side, GSV want to
-
-On the epistemic side, GSV aim to account for asymmetries such as
-
- It might be raining. It's not raining.
- #It's not raining. It might be raining.
-
-## Two-part assignment functions
-
-There are a lot of formal details in the paper in advance of the
-empirical discussion. Here are the ones that matter for our purposes:
-
- type var = string
- type peg = int
- type refsys = var -> peg
- type ent = Alice | Bob | Carl
- type assignment = peg -> ent
-
-So in order to get from a variable to an object, we have to compose a
-refsys `r` with an assignment `g`. For instance, we might have
-r (g ("x")) = Alice. A question to keep in mind as we proceed is why
-the mapping from variables to objects has been articulated into two
-functions. Why not map variables directly to objects? (We'll return
-to this question later.)
-
- type pred = string
- type world = pred -> ent -> bool
- type pegcount = int
- type poss = world * pegcount * refsys * assignment
- type infostate = [poss]
+## Basics of GSV's fragment
-Worlds in general settle all matters of fact in the world. In
-particular, they determine the extensions of predicates and relations.
-In this discussion, we'll (crudely) approximate worlds by making them
-a function from predicates such as "man" to a function mapping each
-entity to a boolean.
+The fragment in this paper is unusually elegant. We'll present it on
+its own terms, with the exception that we will not use pegs. See the
+digression below concerning pegs for an explanation. After presenting
+the paper, we'll re-engineering the fragment using explicit monads.
-As we'll see, indefinites as a side effect increase the number of pegs
-by one. GSV assume that we can determine what integer the next unused
-peg corresponds to by examining the range of the refsys function.
-We'll make things easy on ourselves by simply tracking the total
-number of used pegs in a counter called `pegcount`.
+In this fragment, points of evaluation are not just worlds, but a pair
+of a world and an assginment function. This is familiar from Heim's
+1983 File Change Semantics. We'll follow GSV and call a
+world-assignment pair a "possibility". Then a context is a set (an
+"information state") is a set of possiblities. Infostates
+simultaneously track both information about the world (which possible
+worlds are live possibilities?) as well as information about the
+discourse (which objects to the variables refer to?).
-So information states track both facts about the world (e.g., which
-objects count as a man), and facts about the discourse (e.g., how many
-pegs have been used).
+Worlds in general settle all matters of fact in the world. In
+particular, they determine the extensions of predicates and relations.
The formal language the fragment interprets is Predicate Calculus with
-equality, existential and universal quantification, and one unary
-modality (box and diamond, corresponding to epistemic necessity and
-epistemic possibility).
+equality, existential and universal quantification, along with one
+unary modality (box and diamond, corresponding to epistemic necessity
+and epistemic possibility).
+
+An implementation in OCaml is available [[here|code/gsv.ml]]; consult
+that code for details of syntax, types, and values.
Terms in this language are either individuals such as Alice or Bob, or
else variables. So in general, the referent of a term can depend on a
possibility:
ref(i, t) = t if t is an individual, and
- g(r(t)) if t is a variable, where i = (w,n,r,g)
+ g(t) if t is a variable, where i = (w,g)
Here are the main clauses for update (their definition 3.1).
s[P(t)] = {i in s | w(P)(ref(i,t))}
-So `man(x)` is the set of live possibilities `i = (w,r,g)` in s such that
+So `man(x)` is the set of live possibilities `i = (w,g)` in s such that
the set of men in `w` given by `w(man)` maps the object referred to by
-`x`, namely, `r(g("x"))`, to `true`. That is, update with "man(x)"
+`x`, namely, `g("x")`, to `true`. That is, update with "man(x)"
discards all possibilities in which "x" fails to refer to a man.
- s[t1 = t2] = {i in s | ref(i,t1) = ref(i,t2)}
+ s[t1 = t2] = {i in s | ref(i,t1) == ref(i,t2)}
s[φ and ψ] = s[φ][ψ]
Existential quantification is somewhat intricate.
- s[∃xφ] = Union {{(w, n+1, r[x->n], g[n->a]) | (w,n,r,g) in s}[φ] | a in ent}
+ s[∃xφ] = Union {{(w, g[x->a]) | (w,g) in s}[φ] | a in ent}
Here's the recipe: given a starting infostate s, choose an object a
from the domain of discourse. Construct a modified infostate s' by
-adding a peg to each possibility in s and adjusting the refsys and the
-assignment in order to map the variable x to a. Then update s' with
-φ, and collect the results of doing this for every object a in the
-domain of discourse.
+adjusting the assignment function in order to map the variable x to a.
+Then update s' with φ. Finally, take the union over the results of
+doing this for every object a in the domain of discourse.
Negation is natural enough:
In GSV, disjunction, the conditional, and the universals are defined
in terms of negation and the other connectives (see fact 3.2).
-Exercise: assume that there are two entities in the domain of
-discourse, Alice and Bob. Assume that Alice is a woman, and Bob is a
-man.
-
-We're using `++` here to mean set union.
-
- 1. {(w,n,r,g)}[∃x.person(x)]
+Exercise: assume that there are three entities in the domain of
+discourse, Alice, Bob, and Carl. Assume that Alice is a woman, and
+Bob and Carl are men.
- = {(w,n+1,r[x->n],g[n->a])}[person(x)] ++ {(w,n+1,r[x->n],g[n->b])}[person(x)]
- = {(w,n+1,r[x->n],g[n->a])} ++ {(w,n+1,r[x->n],g[n->b])}
- = {(w,n+1,r[x->n],g[n->a]),(w,n+1,r[x->n],g[n->b])}
- -- both a and b are people
+Compute the following:
- 2. {(w,n,r,g)}[∃x.man(x)]
-
- = {(w,n+1,r[x->n],g[n->a])}[man(x)] ++ {(w,n+1,r[x->n],g[n->b])}[man(x)]
- = {} ++ {(w,n+1,r[x->n],g[n->b])}
- = {(w,n+1,r[x->n],g[n->b])}
- -- only b is a man
-
- 3. {(w,n,r,g)}[∃x∃y.person(x) and person(y)]
-
- = {(w,n+1,r[x->n],g[n->a])}[∃y.person(x) and person(y)]
- ++ {(w,n+1,r[x->n],g[n->b])}[∃y.person(x) and person(y)]
-
- = ( {(w, n+2, r[x->n][y->n+1], g[n->a][n+1->a])}[person(x)][person(y)]
- ++ {(w, n+2, r[x->n][y->n+1], g[n->a][n+1->b])}[person(x)][person(y)])
- ++ ( {(w, n+2, r[x->n][y->n+1], g[n->b][n+1->a])}[person(x)][person(y)]
- ++ {(w, n+2, r[x->n][y->n+1], g[n->b][n+1->b])}[person(x)][person(y)])
-
- = {(w, n+2, r[x->n][y->n+1], g[n->a][n+1->a]),
- (w, n+2, r[x->n][y->n+1], g[n->a][n+1->b])}
- ++ {(w, n+2, r[x->n][y->n+1], g[n->b][n+1->a]),
- (w, n+2, r[x->n][y->n+1], g[n->b][n+1->b])}
-
- = {(w, n+2, r[x->n][y->n+1], g[n->a][n+1->a]),
- (w, n+2, r[x->n][y->n+1], g[n->a][n+1->b]),
- (w, n+2, r[x->n][y->n+1], g[n->b][n+1->a]),
- (w, n+2, r[x->n][y->n+1], g[n->b][n+1->b])}
-
- -- there are four ways of assigning x and y to people
+ 1. {(w,g)}[∃x.man(x)]
+ = {(w,g[n->a])}[man(x)] ++ {(w,g[n->b])}[man(x)]
+ ++ {(w,g[n->c])}[man(x)]
+ = {} ++ {(w,g[n->b])} ++ {(w,g[n->c])}
+ = {(w,g[n->a]),(w,g[n->b]),(w,g[n->c])}
+ -- Bob and Carl are men
+ 2. {(w,g)}[∃x.woman(x)]
+ 3. {(w,g)}[∃x∃y.man(x) and man(y)]
4. {(w,n,r,g)}[∃x∃y.x=y]
- = ( {(w, n+2, r[x->n][y->n+1], g[n->a][n+1->a])}[x=y]
- ++ {(w, n+2, r[x->n][y->n+1], g[n->a][n+1->b])}[x=y]
- ++ ( {(w, n+2, r[x->n][y->n+1], g[n->b][n+1->a])}[x=y]
- ++ {(w, n+2, r[x->n][y->n+1], g[n->b][n+1->b])}[x=y]
-
- = {(w, n+2, r[x->n][y->n+1], g[n->a][n+1->a])}
- ++ {(w, n+2, r[x->n][y->n+1], g[n->b][n+1->b])}
+Running the [[code|code/gsv.ml]] gives the answers.
- = {(w, n+2, r[x->n][y->n+1], g[n->a][n+1->a]),
- (w, n+2, r[x->n][y->n+1], g[n->b][n+1->b])}
-
- -- two ways to assign x and y to the same value
## Order and modality
This is a peculiar rule: a possibility `i` will survive update just in
case something is true of the information state `s` as a whole. That
-means that either every `i` in `s` will survive, or none of them will. The
-criterion is that updating `s` with the information in φ does not
-produce the contradictory information state (i.e., `{}`).
+means that either every `i` in `s` will survive, or none of them will.
+The criterion is that updating `s` with the information in the
+prejacent φ does not produce the contradictory information state
+(i.e., `{}`).
So let's explore what this means. GSV offer a contrast between two
discourses that differ only in the order in which the updates occur.
According to GSV, the combination of these sentences in this order is
`inconsistent', and they mark the second sentence with the star of
ungrammaticality. We'll say instead that the discourse is
-gramamtical, leave the exact word to use for its intuitive effect up
-for grabs. What is important for our purposes is to get clear on how
-the fragment behaves with respect to these sentences.
+gramamtical, leave the exact way to think about its intuitive status
+up for grabs. What is important for our purposes is to get clear on
+how the fragment behaves with respect to these sentences.
We'll start with an infostate containing two possibilities. In one
possibility, Alice is hungry (call this possibility "hungry"); in the
We'll start with the same two possibilities.
-
= {hungry, full}[Alice might be hungry][Alice isn't hungry]
= {hungry, full}[Alice isn't hungry]
= {full}
-Update with *Alice might be hungry* depends on the result of updating
-with the prejacent, *Alice is hungry*. Here's the side calculation:
-
- {hungry, full}[Alice is hungry]
- = {hungry}
-
-Since this update is non-empty, all of the original possibilities
-survive update with *Alice might be hungry*. By now it should be
-obvious that update with a *might* sentence either has no effect, or
-produces an empty information state. The net result is that we can
-then go on to update with *Alice isn't hungry*, yielding an updated
-information state that contains only possibilities in which Alice
-isn't hungry.
-
GSV comment that a single speaker couldn't possibly be in a position
to utter the discourse in (2). The reason is that in order for the
speaker to appropriately assert that Alice isn't hungry, that speaker
hungry, they can utter the discourse in (2). Here's a variant that
makes this thought more vivid:
- 3. Based on public evidence, Alice might be hungry. But in fact she's not hungry.
+ 3. Based on public evidence, Alice might be hungry.
+ But in fact I have private knowledge that she's not hungry.
The main point to appreciate here is that the update behavior of the
discourses depends on the order in which the updates due to the
5. Alice is hungry. (So of course) Alice might be hungry.
Both of these discourses lead to the same update effect: all and only
-those possibilites in which Alice is hungry survive. If you think
-that asserting *might* requires that the prejacent be undecided, you
-will have to consider an update rule for the diamond on which update
-with the prejacent and its negation must both be non-empty.
+those possibilites in which Alice is hungry survive. You might think
+that asserting *might* requires that the prejacent be not only
+possible, but undecided. If you like this idea, you can easily write
+an update rule for the diamond on which update with the prejacent and
+its negation must both be non-empty.
## Order and binding
The GSV fragment differs from the DPL and the DMG dynamic semantics in
-important details. Nevertheless, it has more or less the same things
-to say about anaphora, binding, quantificational binding, and donkey
-anaphora.
+important details. Nevertheless, it says something highly similar to
+DPL about anaphora, binding, quantificational binding, and donkey
+anaphora (at least, when modality is absent, as we'll discuss below).
In particular, continuing the theme of order-based asymmetries,
need an information state whose refsys is defined for at least one
variable.
- 8. {(w,1,r[x->0],g[0->b])}
+ 8. {(w,g[x->b])}
This infostate contains a refsys and an assignment that maps the
variable x to Bob. Here are the facts in world w:
- w "enter" a = false
- w "enter" b = true
- w "enter" c = true
+ extension w "enter" a = false
+ extension w "enter" b = true
+ extension w "enter" c = true
- w "sit" a = true
- w "sit" b = true
- w "sit" c = false
+ extension w "sit" a = true
+ extension w "sit" b = true
+ extension w "sit" c = false
We can now consider the discourses in (6) and (7) (after magically
converting them to the Predicate Calculus):
9. Someone^x entered. He_x sat.
- {(w,1,r[x->0],g[0->b])}[∃x.enter(x)][sit(x)]
+ {(w,g[x->b])}[∃x.enter(x)][sit(x)]
- -- the existential adds a new peg and assigns it to each
- -- entity in turn
-
- = ( {(w,2,r[x->0][x->1],g[0->b][1->a])}[enter(x)]
- ++ {(w,2,r[x->0][x->1],g[0->b][1->b])}[enter(x)]
- ++ {(w,2,r[x->0][x->1],g[0->b][1->c])}[enter(x)])[sit(x)]
+ = ( {(w,g[x->b][x->a])}[enter(x)]
+ ++ {(w,g[x->b][x->b])}[enter(x)]
+ ++ {(w,g[x->b][x->c])}[enter(x)])[sit(x)]
-- "enter(x)" filters out the possibility in which x refers
-- to Alice, since Alice didn't enter
= ( {}
- ++ {(w,2,r[x->0][x->1],g[0->b][1->b])}
- ++ {(w,2,r[x->0][x->1],g[0->b][1->c])})[sit(x)]
+ ++ {(w,g[x->b][x->b])}
+ ++ {(w,g[x->b][x->c])})[sit(x)]
-- "sit(x)" filters out the possibility in which x refers
-- to Carl, since Carl didn't sit
- = {(w,2,r[x->0][x->1],g[0->b][1->b])}
-
-Note that `r[x->0][x->1]` maps `x` to 1---the outermost adjustment is
-the operative one. In other words, `r[x->0][x->1] == (r[x->0])[x->1]`.
+ = {(w,g[x->b][x->b])}
One of the key facts here is that even though the existential has
scope only over the first sentence, in effect it binds the pronoun in
10. He_x sat. Someone^x entered.
- {(w,1,r[x->0],g[0->b])}[sit(x)][∃x.enter(x)]
+ {(w,g[x->b])}[sit(x)][∃x.enter(x)]
-- evaluating `sit(x)` rules out nothing, since (coincidentally)
-- x refers to Bob, and Bob is a sitter
- = {(w,1,r[x->0],g[0->b])}[∃x.enter(x)]
+ = {(w,g[x->b])}[∃x.enter(x)]
-- Just as before, the existential adds a new peg and assigns
-- it to each object
- = {(w,2,r[x->0][x->1],g[0->b][1->a])}[enter(x)]
- ++ {(w,2,r[x->0][x->1],g[0->b][1->b])}[enter(x)]
- ++ {(w,2,r[x->0][x->1],g[0->b][1->c])}[enter(x)]
+ = {(w,g[x->b][x->a])}[enter(x)]
+ ++ {(w,g[x->b][x->b])}[enter(x)]
+ ++ {(w,g[x->b][x->c])}[enter(x)]
-- enter(x) eliminates all those possibilities in which x did
-- not enter
- = {} ++ {(w,2,r[x->0][x->1],g[0->b][1->b])}
- ++ {(w,2,r[x->0][x->1],g[0->b][1->c])}
+ = {} ++ {(w,g[x->b][x->b])}
+ ++ {(w,g[x->b][x->c])}
- = {(w,2,r[x->0][x->1],g[0->b][1->b]),
- (w,2,r[x->0][x->1],g[0->b][1->c])}
+ = {(w,g[x->b][x->b]), (w,g[x->b][x->c])}
The result is different than before. Before, there was only one
possibility: that x refered to the only person who both entered and
entered and spoke not only should not be identified as the person who
sat, he should be different from the person who sat. Some dynamic
systems, such as Heim's File Change Semantics, guarantee non-identity.
-That is not guaranteed by the GSV fragment. The GSV guarantees that
-the indefinite introduces a novel peg, but there is no requirement
-that the peg refers to a novel object. If you wanted to add this as a
-refinement to the fragment, you could require that whenever a new peg
-gets added, it must be mapped onto an object that is not in the range
-of the original assignment function.
+That is not guaranteed by the GSV fragment. If you wanted to add this
+as a refinement to the fragment, you could require that the
+existential only considers object in the domain that are not in the
+range of the starting assignment function.
As usual with dynamic semantics, a point of pride is the ability to
give a good account of donkey anaphora, as in
generalization. GSV illustrate this with the following story.
The Broken Vase:
- There are three sons, Bob, Carl, and Dave.
+ There are three children: Alice, Bob, and Carl.
One of them broke a vase.
- Bob is known to be innocent.
+ Alice is known to be innocent.
Someone is hiding in the closet.
(∃x.closet(x)) and (◊guilty(x)) ≡/≡ ∃x (closet(x) and ◊guilty(x))
in closet guilty
--------------- ---------------
- w: b false b false
- c false c false
- d true d true
-
- w': b false b false
+ w: a true a false
+ b false b true
c true c false
- d false d true
-GSV observe that (∃x.closet(x)) and (◊guilty(x)) is true if there is
-at least one possibility in which a person in the closet is guilty.
-In this scenario, world w is the verifying world. It remains possible
-that there are closet hiders who are not guilty in any world. Carl
-fits this bill: he's in the closet in world w', but he is not guilty
-in any world.
+ w': a false a false
+ b false b false
+ c true c true
+
+GSV say that (∃x.closet(x)) and (◊guilty(x)) is true if there is at
+least one possibility in which a person in the closet is guilty. In
+this scenario, world w' is the verifying world: Carl is in the closet,
+and he's guilty. It remains possible that there are closet hiders who
+are not guilty in any world. Alice fits this bill: she's in the
+closet in world w', but she is not guilty in any world.
Let's see how this works out in detail.
14. Someone^x is in the closet. He_x might be guilty.
- {(w,0,r,g), (w',0,r,g}[∃x.closet(x)][◊guilty(x)]
+ {(w,g), (w',g}[∃x.closet(x)][◊guilty(x)]
-- existential introduces new peg
- = ( {(w,1,r[x->0],g[0->b])}[closet(x)]
- ++ {(w,1,r[x->0],g[0->c])}[closet(x)]
- ++ {(w,1,r[x->0],g[0->d])}[closet(x)]
- ++ {(w',1,r[x->0],g[0->b])}[closet(x)]
- ++ {(w',1,r[x->0],g[0->c])}[closet(x)]
- ++ {(w',1,r[x->0],g[0->d])}[closet(x)])[◊guilty(x)]
+ = ( {(w,g[x->a])}[closet(x)]
+ ++ {(w,g[x->b])}[closet(x)]
+ ++ {(w,g[x->c])}[closet(x)]
+ ++ {(w',g[x->a])}[closet(x)]
+ ++ {(w',g[x->b])}[closet(x)]
+ ++ {(w',g[x->c])}[closet(x)])[◊guilty(x)]
-- only possibilities in which x is in the closet survive
+ -- the first update
- = {(w,1,r[x->0],g[0->d]),
- (w',1,r[x->0],g[0->c])}[◊guilty(x)]
+ = {(w,g[x->a]), (w',g[x->c])}[◊guilty(x)]
-- Is there any possibility in which x is guilty?
- -- yes: for x = Dave, in world w Dave broke the vase
+ -- yes: for x = Carl, in world w' Carl broke the vase
+ -- that's enough for the possiblity modal to allow the entire
+ -- infostate to pass through unmodified.
- = {(w,1,r[x->0],g[0->d]),
- (w',1,r[x->0],g[0->c])}
+ = {(w,g[x->a]),(w',g[x->c])}
Now we consider the second half:
- 14. Someone^x is in the closet who_x might be guilty.
+ 15. Someone^x is in the closet who_x might be guilty.
- {(w,0,r,g), (w',0,r,g)}[∃x(closet(x) & ◊guilty(x))]
+ {(w,g), (w',g)}[∃x(closet(x) & ◊guilty(x))]
- -- existential introduces new peg
-
- = {(w,1,r[x->0],g[0->b])}[closet(x)][◊guilty(x)]
- ++ {(w,1,r[x->0],g[0->c])}[closet(x)][◊guilty(x)]
- ++ {(w,1,r[x->0],g[0->d])}[closet(x)][◊guilty(x)]
- ++ {(w',1,r[x->0],g[0->b])}[closet(x)][◊guilty(x)]
- ++ {(w',1,r[x->0],g[0->c])}[closet(x)][◊guilty(x)]
- ++ {(w',1,r[x->0],g[0->d])}[closet(x)][◊guilty(x)]
+ = {(w,g[x->a])}[closet(x)][◊guilty(x)]
+ ++ {(w,g[x->b])}[closet(x)][◊guilty(x)]
+ ++ {(w,g[x->c])}[closet(x)][◊guilty(x)]
+ ++ {(w',g[x->a])}[closet(x)][◊guilty(x)]
+ ++ {(w',g[x->b])}[closet(x)][◊guilty(x)]
+ ++ {(w',g[x->c])}[closet(x)][◊guilty(x)]
-- filter out possibilities in which x is not in the closet
-- and filter out possibilities in which x is not guilty
- -- the only person who was guilty in the closet was Dave in
- -- world 1
+ -- the only person who was guilty in the closet was Carl in
+ -- world w'
+
+ = {(w',g[x->c])}
- = {(w,1,r[x->0],g[0->d])}
+The result is different. Fewer possibilities remain.
+We have elminated both possible worlds and possible discourses.
+So the second formula is more informative.
+
+As we discovered in class, there is considerable work to be done to
+decide which expressions in natural language (if any) are capable of
+expressing which of the two translations into the GSV fragment. We
+can certainly grasp the truth conditions, but that is not the same
+thing as discovering that there are natural language sentences that
+express one or the other or both.
-The result is different, and more informative.
## Binding, modality, and identity
The fragment correctly predicts the following contrast:
- 15. Someone^x entered. He_x might be Bob. He_x might not be Bob.
+ 16. Someone^x entered. He_x might be Bob. He_x might not be Bob.
(∃x.enter(x)) & ◊x=b & ◊not(x=b)
-- This discourse requires a possibility in which Bob entered
-- and another possibility in which someone who is not Bob entered
- 16. Someone^x entered who might be Bob and who might not be Bob.
+ 17. Someone^x entered who might be Bob and who might not be Bob.
∃x (enter(x) & ◊x=b & ◊not(x=b))
-- This is a contradition: there is no single person who might be Bob
-- and who simultaneously might be someone else
add individual concepts to the fragment, the ability to express
fancier claims would come along.
-### Identifiers
+## GSV's "Identifiers"
Let α be a term which differs from x. Then α is an identifier if the
following formula is supported by every information state:
A term is an identifier per se if no mattter what the information
state is, it cannot fail to decie what the denotation of the term is.
-## Why have a two-part assignment function?
-
-In the current system, variables are associated with values in two
-steps.
-
- Variables Pegs Entities
- --------- r ---- g --------
- x --> 0 --> a
- y --> 1 --> b
- z --> 2 --> c
-
-Here, r is a refsys mapping variables to pegs, and g is an assignment
-function mapping pegs to entities.
-
-Assignment functions are free to map different pegs to the same
-entity:
+## Digression on pegs
- Variables Pegs Entities
- --------- r ---- g --------
- x --> 0 --> a
- y --> 1 --> a
- z --> 2 --> c
-
-But this is possible with ordinary assignment functions as well.
+One of the more salient aspects of the technical part of the paper is
+that GSV insert an extra level in between the variable and the object:
+instead of having an assignment function that maps variables directly
+onto objects, GSV provide *pegs*: variables map onto pegs, and pegs
+map onto objects. It happens that pegs play no role in the paper
+whatsoever. We'll demonstrate this by providing a faithful
+implementation of the paper that does not use pegs at all.
-It is possible to imagine a refsys that maps more than one variable to
-the same peg. But the fragment is designed to prevent that from ever
-happening: the only way to associate a variable with a peg is by
-evaluating an existential quantifier, and the existential quantifier
-always introduces a fresh, unused peg.
+Nevertheless, it makes sense to pause here to discuss pegs briefly,
+since this technique is highly relevant to one of the main
+applications of the course, namely, reference and coreference.
-So what does the bipartite system do that ordinary assignment
-functions can't do?
+What are pegs? The term harks back to a 1986 paper by Fred Landman
+called `Pegs and Alecs'. Pegs are simply hooks for hanging properties
+on. Pegs are supposed to be as anonymous as possible. Think of
+hanging your coat on a physical peg: you don't care which peg it is,
+only that there are enough pegs for everyone's coat to hang from.
+Likewise, for the pegs of GSV, all that matters is that there are
+enough of them. (Incidentally, there is nothing in Gronendijk and
+Stokhof's original DPL paper that corresponds naturally to pegs; but
+in their Dynamic Montague Grammar paper, pegs serve a purpose similar
+to discourse referents there, though the connection is not simple.)
+
+Pegs can be highly useful for exploring puzzles of reference and
+coreference.
+
+ Standard assignment function System with Pegs (drefs)
+ ---------------------------- ------------------------
+ Variable Object Var Peg Object
+ --------- ------- --- --- ------
+ x --> a x --> 0 --> a
+ y -/ y -/
+ z --> b z --> 1 --> a
+
+A standard assignment function can map two different variables onto
+the same object. In the diagram, x and y are both mapped onto the
+object a. With discourse referents in view, we can have two different
+flavors of coreference. Just as with ordinary assignment functions,
+variables can be mapped onto pegs (discourse referents) that are in
+turn mapped onto the same object. In the diagram, x is mapped onto
+the peg 0, which in turn is mapped onto the object a, and z is mapped
+onto a discourse referent that is mapped onto a. On a deeper level,
+we can suppose that y is mapped onto the same discourse referent as
+x. With a system like this, we are free to reassign the discourse
+referent associated with z to a different object, in which case x and
+z will no longer refer to the same object. But there is no way to
+change the object associated with x without necessarily changing the
+object associated with y. They are coreferent in a deeper, less
+accidental sense.
+
+GSV could make use of this expressive power. But they don't. In
+fact, their system is careful designed to guarantee that every
+variable is assigned a discourse referent distinct from all previous
+discourse referents.
+
+End of digression on pegs.