fix typo on ski_evaluator
[lambda.git] / topics / _week8_intensionality.mdwn
1 Now we'll look at using monads to do intensional function application.
2 This is just another application of the Reader monad, not a new monad.
3 In Shan (2001) [Monads for natural
4 language semantics](http://arxiv.org/abs/cs/0205026v1), Ken shows that
5 making expressions sensitive to the world of evaluation is conceptually
6 the same thing as making use of the Reader monad.
7 This technique was beautifully re-invented
8 by Ben-Avi and Winter (2007) in their paper [A modular
9 approach to
10 intensionality](http://parles.upf.es/glif/pub/sub11/individual/bena_wint.pdf),
11 though without explicitly using monads.
12
13 All of the code in the discussion below can be found here: [[code/intensionality-monad.ml]].
14 To run it, download the file, start OCaml, and say 
15
16         # #use "intensionality-monad.ml";;
17
18 Note the extra `#` attached to the directive `use`.
19
20 First, the familiar linguistic problem:
21
22        Bill left.  
23            Cam left.
24            Ann believes [Bill left].
25            Ann believes [Cam left].
26
27 We want an analysis on which the first three sentences can be true at
28 the same time that the last sentence is false.  If sentences denoted
29 simple truth values or booleans, we have a problem: if the sentences
30 *Bill left* and *Cam left* are both true, they denote the same object,
31 and Ann's beliefs can't distinguish between them.
32
33 The traditional solution to the problem sketched above is to allow
34 sentences to denote a function from worlds to truth values, what
35 Montague called an intension.  So if `s` is the type of possible
36 worlds, we have the following situation:
37
38
39 <pre>
40 Extensional types              Intensional types       Examples
41 -------------------------------------------------------------------
42
43 S         t                    s->t                    John left
44 DP        e                    s->e                    John
45 VP        e->t                 (s->e)->s->t            left
46 Vt        e->e->t              (s->e)->(s->e)->s->t    saw
47 Vs        t->e->t              (s->t)->(s->e)->s->t    thought
48 </pre>
49
50 This system is modeled on the way Montague arranged his grammar.
51 There are significant simplifications compared to Montague: for
52 instance, determiner phrases are thought of here as corresponding to
53 individuals rather than to generalized quantifiers.
54
55 The main difference between the intensional types and the extensional
56 types is that in the intensional types, the arguments are functions
57 from worlds to extensions: intransitive verb phrases like "left" now
58 take so-called "individual concepts" as arguments (type s->e) rather than plain
59 individuals (type e), and attitude verbs like "think" now take
60 propositions (type s->t) rather than truth values (type t).
61 In addition, the result of each predicate is an intension.
62 This expresses the fact that the set of people who left in one world
63 may be different than the set of people who left in a different world.
64
65 Normally, the dependence of the extension of a predicate to the world
66 of evaluation is hidden inside of an evaluation coordinate, or built
67 into the the lexical meaning function, but we've made it explicit here
68 in the way that the intensionality monad makes most natural.
69
70 The intensional types are more complicated than the extensional
71 types.  Wouldn't it be nice to make the complicated types available
72 for those expressions like attitude verbs that need to worry about
73 intensions, and keep the rest of the grammar as extensional as
74 possible?  This desire is parallel to our earlier desire to limit the
75 concern about division by zero to the division function, and let the
76 other functions, like addition or multiplication, ignore
77 division-by-zero problems as much as possible.
78
79 So here's what we do:
80
81 In OCaml, we'll use integers to model possible worlds. Characters (characters in the computational sense, i.e., letters like `'a'` and `'b'`, not Kaplanian characters) will model individuals, and OCaml booleans will serve for truth values:
82
83         type s = int;;
84         type e = char;;
85         type t = bool;;
86
87         let ann = 'a';;
88         let bill = 'b';;
89         let cam = 'c';;
90
91         let left1 (x:e) = true;; 
92         let saw1 (x:e) (y:e) = y < x;; 
93
94         left1 ann;; (* true *)
95         saw1 bill ann;; (* true *)
96         saw1 ann bill;; (* false *)
97
98 So here's our extensional system: everyone left, including Ann;
99 and Ann saw Bill (`saw1 bill ann`), but Bill didn't see Ann.  (Note that the word
100 order we're using is VOS, verb-object-subject.)
101
102 Now we add intensions.  Because different people leave in different
103 worlds, the meaning of *leave* must depend on the world in which it is
104 being evaluated:
105
106     let left (x:e) (w:s) = match (x, w) with ('c', 2) -> false | _ -> true;;
107     left ann 1;; (* true: Ann left in world 1 *)
108     left cam 2;; (* false: Cam didn't leave in world 2 *) 
109
110 This new definition says that everyone always left, except that 
111 in world 2, Cam didn't leave.
112
113 Note that although this general *left* is sensitive to world of
114 evaluation, it does not have the fully intensionalized type given in
115 the chart above, which was `(s->e)->s->t`.  This is because
116 *left* does not exploit the additional resolving power provided by
117 making the subject an individual concept.  In semantics jargon, we say
118 that *leave* is extensional with respect to its first argument.  
119
120 Therefore we will adopt the general strategy of defining predicates
121 in a way that they take arguments of the lowest type that will allow
122 us to make all the distinctions the predicate requires.  When it comes
123 time to combine this predicate with monadic arguments, we'll have to
124 make use of various lifting predicates.
125
126 Likewise, although *see* depends on the world of evaluation, it is
127 extensional in both of its syntactic arguments:
128
129     let saw x y w = (w < 2) && (y < x);;
130     saw bill ann 1;; (* true: Ann saw Bill in world 1 *)
131     saw bill ann 2;; (* false: no one saw anyone in world 2 *)
132
133 This (again, partially) intensionalized version of *see* coincides
134 with the `saw1` function we defined above for world 1; in world 2, no
135 one saw anyone.
136
137 Just to keep things straight, let's review the facts:
138
139 <pre>
140      World 1: Everyone left.
141               Ann saw Bill, Ann saw Cam, Bill saw Cam, no one else saw anyone.              
142      World 2: Ann left, Bill left, Cam didn't leave.
143               No one saw anyone.
144 </pre>
145
146 Now we are ready for the intensionality monad:
147
148 <pre>
149 type 'a intension = s -> 'a;;
150 let unit x = fun (w:s) -> x;;
151 (* as before, bind can be written more compactly, but having
152    it spelled out like this will be useful down the road *)
153 let bind u f = fun (w:s) -> let a = u w in let u' = f a in u' w;;
154 </pre>
155
156 Then the individual concept `unit ann` is a rigid designator: a
157 constant function from worlds to individuals that returns `'a'` no
158 matter which world is used as an argument.  This is a typical kind of
159 thing for a monad unit to do.
160
161 Then combining a predicate like *left* which is extensional in its
162 subject argument with an intensional subject like `unit ann` is simply bind
163 in action:
164
165     bind (unit ann) left 1;; (* true: Ann left in world 1 *)
166     bind (unit cam) left 2;; (* false: Cam didn't leave in world 2 *)
167
168 As usual, bind takes a monad box containing Ann, extracts Ann, and
169 feeds her to the extensional *left*.  In linguistic terms, we take the
170 individual concept `unit ann`, apply it to the world of evaluation in
171 order to get hold of an individual (`'a'`), then feed that individual
172 to the extensional predicate *left*.
173
174 We can arrange for a transitive verb that is extensional in both of
175 its arguments to take intensional arguments:
176
177     let lift2' f u v = bind u (fun x -> bind v (fun y -> f x y));;
178
179 This is almost the same `lift2` predicate we defined in order to allow
180 addition in our division monad example.  The difference is that this
181 variant operates on verb meanings that take extensional arguments but
182 returns an intensional result.  Thus the original `lift2` predicate
183 has `unit (f x y)` where we have just `f x y` here.
184   
185 The use of `bind` here to combine *left* with an individual concept,
186 and the use of `lift2'` to combine *see* with two intensional
187 arguments closely parallels the two of Montague's meaning postulates
188 (in PTQ) that express the relationship between extensional verbs and
189 their uses in intensional contexts.
190
191 <pre>
192 lift2' saw (unit bill) (unit ann) 1;;  (* true *)
193 lift2' saw (unit bill) (unit ann) 2;;  (* false *)
194 </pre>
195
196 Ann did see bill in world 1, but Ann didn't see Bill in world 2.
197
198 Finally, we can define our intensional verb *thinks*.  *Think* is
199 intensional with respect to its sentential complement, though still extensional
200 with respect to its subject.  (As Montague noticed, almost all verbs
201 in English are extensional with respect to their subject; a possible
202 exception is "appear".)
203
204     let thinks (p:s->t) (x:e) (w:s) = 
205       match (x, p 2) with ('a', false) -> false | _ -> p w;;
206
207 Ann disbelieves any proposition that is false in world 2.  Apparently,
208 she firmly believes we're in world 2.  Everyone else believes a
209 proposition iff that proposition is true in the world of evaluation.
210
211     bind (unit ann) (thinks (bind (unit bill) left)) 1;;
212
213 So in world 1, Ann thinks that Bill left (because in world 2, Bill did leave).
214
215     bind (unit ann) (thinks (bind (unit cam) left)) 1;;
216
217 But in world 1, Ann doesn't believe that Cam left (even though he
218 did leave in world 1: `bind (unit cam) left 1 == true`).  Ann's thoughts are hung up on
219 what is happening in world 2, where Cam doesn't leave.
220
221 *Small project*: add intersective ("red") and non-intersective
222  adjectives ("good") to the fragment.  The intersective adjectives
223  will be extensional with respect to the nominal they combine with
224  (using bind), and the non-intersective adjectives will take
225  intensional arguments.
226
227