cat theory tweaks
[lambda.git] / reader_monad.mdwn
index 0da42ec..b0f6486 100644 (file)
@@ -194,31 +194,32 @@ I guess you haven't you been paying close enough attention, or you don't have mu
 
 In Heim and Kratzer's textbook <cite>Semantics in Generative Grammar</cite>, the interpretation of complex phrases like \[[interprets complex phrases]] are trees that look like this:
 
-
-                                       VP
-                                 /    \
-                                /      \
-                               /        \
-                          /          \
-                         /            \
-                        /              NP
-                       /              /  \
-                  /              /    \
-                  V             /      \
-                  |            /        \
-        \[[interprets]]    AP         N
-                                         / \         |
-                                 \[[complex]] \[[phrases]]
-
-
-Now the normal way in which the nodes of such trees are related to each other is that the semantic value of a parent node is the result of applying the functional value of one of the daughter nodes to the value of the other daughter node. (The types determine which side is the function and which side is the argument.) One exception to this general rule is when multiple adjectives are joined together, as happens in `\[[interprets complex English phrases]]`. We'll ignore that though.
+<blockquote><pre>
+                               VP
+                         /    \
+                        /      \
+                       /        \
+                  /          \
+                 /            \
+                /              NP
+               /              /  \
+          /              /    \
+          V             /      \
+          |            /        \
+\[[interprets]]    AP         N
+                                 / \         |
+                         \[[complex]] \[[phrases]]
+</pre></blockquote>
+
+
+Now the normal way in which the nodes of such trees are related to each other is that the semantic value of a parent node is the result of applying the functional value of one of the daughter nodes to the value of the other daughter node. (The types determine which side is the function and which side is the argument.) One exception to this general rule is when multiple adjectives are joined together, as happens in \[[interprets complex English phrases]]. We'll ignore that though.
 
 Another exception is that Heim and Kratzer have to postulate a special rule to handle lambda abstraction. (This is their "Predicate Abstraction Rule.") Not only is it a special rule, but it's arguably not even a compositional rule. The basic idea is this. The semantic value of:
 
        \[[man who(i): Alice spurned i]]
 
-is the result of combining `[[man]]`, an `e->t` type predicate value, with the adjective-type value of `[[who(i): Alice spurned i]]`. As I said, we'll ignore complexities about their treatment of adjectives. But how is `[[who(i): Alice spurned i]]` derived? Heim and Kratzer say this is defined only relative to an
-assignment g, and it's defined to be a function from objects x in the domain to the value `[[Alice spurned i]]` has relative to shifted assignment g{i:=x}, which is like g except for assigning object x to variable i. So this is not the result of taking some value `[[who(i)]]`, and some separate value `[[Alice spurned i]]`, and supplying one of them to the other as argument to function.
+is the result of combining \[[man]], an `e->t` type predicate value, with the adjective-type value of \[[who(i): Alice spurned i]]. As I said, we'll ignore complexities about their treatment of adjectives. But how is \[[who(i): Alice spurned i]] derived? Heim and Kratzer say this is defined only relative to an
+assignment g, and it's defined to be a function from objects x in the domain to the value \[[Alice spurned i]] has relative to shifted assignment g{i:=x}, which is like g except for assigning object x to variable i. So this is not the result of taking some value \[[who(i)]], and some separate value \[[Alice spurned i]], and supplying one of them to the other as argument to function.
 
 Getting any ideas?
 
@@ -243,7 +244,7 @@ That is, it takes as arguments a clause-type reader-monad `u`, and an entity-typ
 
 You can trace through what happens then if we apply \[[who(i)]] to (\[[spurned]] applied to \[[Alice]] and \[[i]]):
 
-       [[Alice spurned i]] = [[spurned]] [[Alice]] [[i]]
+       \[[Alice spurned i]] = \[[spurned]] \[[Alice]] \[[i]]
                = (lift2 S) (unit Alice) (lookup i)
                = bind (unit Alice) (fun x -> bind (lookup i) (fun y -> unit (S x y)))
 
@@ -262,7 +263,7 @@ Substituting in the definition of `unit`, this is:
 
 And now supplying \[[Alice spurned i]] as an argument to \[[who(i)]], we get:
 
-       [[who(i): Alice spurned i]] = [[who(i)]] [[Alice spurned i]]
+       \[[who(i): Alice spurned i]] = \[[who(i)]] \[[Alice spurned i]]
                = (fun u v -> shift i v u) (fun e -> S Alice (lookup i e))
                = fun v -> shift i v (fun e -> S Alice (lookup i e))