39dd8028e50b199c6d713e6430b3c7097633e688
[lambda.git] / intensionality_monad.mdwn
1 Now we'll look at using monads to do intensional function application.
2 This really 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: [[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 all four of these sentences can be true
28 simultaneously.  If sentences denoted simple truth values or booleans,
29 we have a problem: if the sentences *Bill left* and *Cam left* are
30 both true, they denote the same object, and Ann's beliefs can't
31 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: for instance, determiner
52 phrases are thought of as corresponding to individuals rather than to
53 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 intensional 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 Normally, the dependence of the extension of a predicate to the world
65 of evaluation is hidden inside of an evaluation coordinate, or built
66 into the the lexical meaning function, but we've made it explicit here
67 in the way that the intensionality monad makes most natural.
68
69 The intenstional types are more complicated than the intensional
70 types.  Wouldn't it be nice to make the complicated types available
71 for those expressions like attitude verbs that need to worry about
72 intensions, and keep the rest of the grammar as extensional as
73 possible?  This desire is parallel to our earlier desire to limit the
74 concern about division by zero to the division function, and let the
75 other functions, like addition or multiplication, ignore
76 division-by-zero problems as much as possible.
77
78 So here's what we do:
79
80 In OCaml, we'll use integers to model possible worlds:
81
82         type s = int;;
83         type e = char;;
84         type t = bool;;
85
86 Characters (characters in the computational sense, i.e., letters like
87 `'a'` and `'b'`, not Kaplanian characters) will model individuals, and
88 OCaml booleans will serve for truth values.
89
90 <pre>
91 let ann = 'a';;
92 let bill = 'b';;
93 let cam = 'c';;
94
95 let left1 (x:e) = true;; 
96 let saw1 (x:e) (y:e) = y < x;; 
97
98 left1 ann;;
99 saw1 bill ann;; (* true *)
100 saw1 ann bill;; (* false *)
101 </pre>
102
103 So here's our extensional system: everyone left, including Ann;
104 and Ann saw Bill, but Bill didn't see Ann.  (Note that Ocaml word
105 order is VOS, verb-object-subject.)
106
107 Now we add intensions.  Because different people leave in different
108 worlds, the meaning of *leave* must depend on the world in which it is
109 being evaluated:
110
111     let left (x:e) (w:s) = match (x, w) with ('c', 2) -> false | _ -> true;;
112
113 This new definition says that everyone always left, except that 
114 in world 2, Cam didn't leave.
115
116     let saw x y w = (w < 2) && (y < x);;
117     saw bill ann 1;; (* true: Ann saw Bill in world 1 *)
118     saw bill ann 2;; (* false: no one saw anyone in world 2 *)
119
120 Along similar lines, this general version of *see* coincides with the
121 `saw1` function we defined above for world 1; in world 2, no one saw anyone.
122
123 Just to keep things straight, let's get the facts of the world set:
124
125 <pre>
126      World 1: Everyone left.
127               Ann saw Bill, Ann saw Cam, Bill saw Cam, no one else saw anyone.              
128      World 2: Ann left, Bill left, Cam didn't leave.
129               No one saw anyone.
130 </pre>
131
132 Now we are ready for the intensionality monad:
133
134 <pre>
135 type 'a intension = s -> 'a;;
136 let unit x (w:s) = x;;
137 let bind m f (w:s) = f (m w) w;;
138 </pre>
139
140 Then the individual concept `unit ann` is a rigid designator: a
141 constant function from worlds to individuals that returns `'a'` no
142 matter which world is used as an argument.  This is a typical kind of
143 thing for a monad unit to do.
144
145 Then combining a prediction like *left* which is extensional in its
146 subject argument with a monadic subject like `unit ann` is simply bind
147 in action:
148
149     bind (unit ann) left 1;; (* true: Ann left in world 1 *)
150     bind (unit cam) left 2;; (* false: Cam didn't leave in world 2 *)
151
152 As usual, bind takes a monad box containing Ann, extracts Ann, and
153 feeds her to the extensional *left*.  In linguistic terms, we take the
154 individual concept `unit ann`, apply it to the world of evaluation in
155 order to get hold of an individual (`'a'`), then feed that individual
156 to the extensional predicate *left*.
157
158 We can arrange for an extensional transitive verb to take intensional
159 arguments:
160
161     let lift f u v = bind u (fun x -> bind v (fun y -> f x y));;
162
163 This is the exact same lift predicate we defined in order to allow
164 addition in our division monad example.
165
166 <pre>
167 lift saw (unit bill) (unit ann) 1;;  (* true *)
168 lift saw (unit bill) (unit ann) 2;;  (* false *)
169 </pre>
170
171 Ann did see bill in world 1, but Ann didn't see Bill in world 2.
172
173 Finally, we can define our intensional verb *thinks*.  *Think* is
174 intensional with respect to its sentential complement, but extensional
175 with respect to its subject.  (As Montague noticed, almost all verbs
176 in English are extensional with respect to their subject; a possible
177 exception is "appear".)
178
179     let thinks (p:s->t) (x:e) (w:s) = 
180       match (x, p 2) with ('a', false) -> false | _ -> p w;;
181
182 Ann disbelieves any proposition that is false in world 2.  Apparently,
183 she firmly believes we're in world 2.  Everyone else believes a
184 proposition iff that proposition is true in the world of evaluation.
185
186     bind (unit ann) (thinks (bind (unit bill) left)) 1;;
187
188 So in world 1, Ann thinks that Bill left (because in world 2, Bill did leave).
189
190     bind (unit ann) (thinks (bind (unit cam) left)) 1;;
191
192 But even in world 1, Ann doesn't believe that Cam left (even though he
193 did: `bind (unit cam) left 1 == true`).  Ann's thoughts are hung up on
194 what is happening in world 2, where Cam doesn't leave.
195
196 *Small project*: add intersective ("red") and non-intersective
197  adjectives ("good") to the fragment.  The intersective adjectives
198  will be extensional with respect to the nominal they combine with
199  (using bind), and the non-intersective adjectives will take
200  intensional arguments.