CHAPTER FOUR: BACKWARD λ-CONVERSION AND CROSS-CATEGORIAL
CONNECTIVES
4.1. Backward λ-conversion.
The aim of this section is to show how, given assumptions about the syntax, the syntaxsemantics relation, and certain basic type assignments, backward λ-conversion helps you to
find the compositional interpretation of the expressions and hence helps you in defining the
grammar.
We will start with the following example:
(1) John doesn't walk.
Our aim will be to find a compositional semantics for this example, and to write a grammar.
Let us start by assuming a simple syntax.
We assume the following syntactic categories: NP, VP, NEG, S
We assume the following syntactic rules:
NP + VP ==> S
NEG + VP ==> VP
And we assume the following lexical items:
NP
│
john
VP NEG
│
│
walk not
We're ignoring everything having to do with do and with subject verb agreement, and assume
that for our purposes here generating John not walk is fine enough. Given this, we generate
our sentence with the following structure:
S
NP
VP
│
John NEG
VP
│
│
not
walk
We have now made some assumptions about the syntax, let us make some assumptions about
the relation between syntactic categories and semantics types.
First let us make Montague's Fixed Type Assignment assumption [Montague 1974]:
101
Fixed Type Assignment:
we associate with every syntactic category one and only one semantic type, and all
expressions of that syntactic category are semantically interpreted as expressions of
that semantic type.
Secondly let us assume, as before, that intransitive verbs are interpreted as predicates of type
<e,t>, and that sentences are interpreted as expressions of type t.
So we associate with VP type <e,t> and with S type t.
This fixes the semantic types corresponding to the above tree as follows:
t
.
│
John
<e,t>
.
<e,t>
│
│
not walk
Next let us assume that all the syntactic rules that we have given are interpreted semantically
as functional application.
We then have to decide which expression is going to be the function and which is going to be
the argument.
We have two syntactic rules:
NP + VP ==> S
NEG + VP ==> VP
As before, the grammar produces pairs of the form <α,α'> where α is a syntactic tree and α'
its translation in type logic.
We then have four possibilities for our rules:
R1. <NP,NP'> + <VP,VP'> ==> < S , VP'(NP')>
NP
VP
R2. <NP,NP'> + <VP,VP'> ==> < S , NP'(VP')>
NP
VP
R3. <NEG,NEG'> + <VP,VP'> ==> < VP , NEG'(VP')>
NEG
VP
R4. <NEG,NEG'> + <VP,VP'> ==> < VP , VP'(NEG')>
NEG
VP
102
Of these four, the last rule R4 is incompatible with our assumptions so far. We have
assumed that the type of VP is <e,t>. But if NEG is the argument of VP, its type has to be e,
and the type of the output VP would be t. But we have already fixed the type of VP to be
<e,t>.
Hence we know that our grammar will contain rule R3 and not R4:
R3. <NEG,NEG'> + <VP,VP'> ==> < VP , NEG'(VP')>
NEG
VP
This fixes the type of NEG. Clearly, its type has to be <<e,t>,<e,t>>.
So we have gotten the following information:
t
.
<e,t>
│
John <<e,t>,<e,t>>
<e,t>
│
│
not
walk
Given that we have decided to follow Montague here in assuming the Fixed Type
Assignment assumption, and given the fact that we have assumed that the type assigned to
VP is <e,t>, both rules R1 and R2 are still compatible with this particular example. Rule R1
tells us that the type assigned to NP is e; rule R2 tells us that the NP is the function, giving t
as output type, which can only mean that the type assigned to NP is <<e,t,>,t>.
This particular example doesn't decide between these two, but other considerations do.
The grammar that we are going to make should not only generate the above sentence, but
should work generally, for other NPs as well. That is, we want a grammar that would also be
capable of generating every boy walks.
But that means that under our assumptions, rule R1 would require the NP every boy also to
be of type e.
But that is semantically problematic, because as an expression of type e, it would have to
denote an individual, and, of course, quantified NPs do not denote individuals.
These considerations lead us to disregard rule R1.
Note: we only disregard rule 1 given our assumptions of the Fixed Type Assignment
assumption and our choice of letting the type of VP be <e,t>. As we will see later, it is quite
well possible (and in fact rather common) to assume a grammar that has rule R1 rather than
(or besides) rule R2. But such a grammar gives up the FTA or the assignment <e,t> to VP, or
both. Here we are making both assumptions, so the rule for combining a subject with an
intransitive verb phrase is rule R2:
103
R2. <NP,NP'> + <VP,VP'> ==> < S , NP'(VP')>
NP
VP
This fixes all the types in our example as follows:
t
<<e,t>,t>
<e,t>
│
John <<e,t>,<e,t>>
│
not
<e,t>
│
walk
Now, we could finish our grammar easily by adding the following lexical entries:
<VP,WALK>
│
walk
where WALK  CON<e,t>
<NEG,NOT>
│
not
where NOT  CON<<e,t>,<e,t>>
<NP,JOHN>
│
John
where JOHN  CON<<e,t>,t>
and get as a semantic representation for the sentence:
(JOHN((NOT(WALK)))
The problem is that, as a semantic representation, this is not informative enough.
Let us assume that John is an individual and that the constant j  CONe denotes him. Our
constant JOHN denotes a set of properties, and nothing so far requires that there is any
connection between that set of properties and the individual John. Similarly, our constant
NOT denotes some function from properties into properties, but nothing yet tells us what the
relation is between the property NOT(WALK) and the property WALK.
That is, this representation does not yet support the entailments that we intuitively associate
with the sentence.
Our task is not just to stipulate meanings for our lexical items, but rather to find out what
they are. In other words, our semantics is not explicit enough if it doesn't explain the relation
between the meaning of john at type <<e,t>,t> and the individual John, which is denoted by
our constant j  CONe. Similarly, we need to explain the relation between not at type
104
<<e,t>,<e,t>> and sentential negation ¬.
Given that we have assumed that walk is interpreted as an expression of type <e,t>, a
property, -and we're not here interested in trying to lexically decompose its meaning- we will
assume that we interpret this as a constant of type <e,t>. Hence, we do assume the lexical
entry for walk:
<VP,WALK>
│
walk
where WALK  CON<e,t>
Assuming that our constant j  CONe denotes John, we do know what the meaning of the
whole sentence should be, namely: ¬WALK(j).
Thus we have the following semantic information:
t ¬WALK(j)
<<e,t>,t>
<e,t>
│
JOHN <<e,t>,<e,t>>
│
NOT
<e,t>
│
WALK
Our task now is to find the correct interpretations of the other expressions.
We know that semantically, the meaning corresponding to the topnode should be:
S' = ((NP'((NEG'(VP')))
Since VP' = WALK and S' = ¬WALK(j), we know that NP' and NEG' should be expressions
that satisfy the following equation:
¬WALK(j) = ((NP'((NEG'(WALK)))
Here is where backward λ-conversion comes in.
¬WALK(j) is an expression that has the constant j sitting in the middle. Now obviously,
whatever the interpretation of NP' is going to be, it should be responsible for the introduction
of the constant j.
That means that j should be part of the NP' expression.
This means that we are looking for an expression in which j is not the argument of WALK,
but is part of an expression that takes an expression with WALK in it as an argument. So we
need to pull j out of the expression ¬WALK(j). We do that through backward λ-conversion:
105
¬WALK(j)
= [λx.¬WALK(x)](j)
[backward λ-con]
where x  VARe.
As we have seen these two expressions are equivalent by λ-conversion. λx.¬WALK(x) is an
expression of type <e,t>, which is very promising, because we need an expression of exactly
that type to be the interpretation of the VP not walk.
However, in the above expression j is an argument of the predicate λx.¬WALK(x), while
what we need is a representation where it is in a function that takes the expression
representing the contribution of negation and WALK as its argument.
We bring the expression in that form by once more backward λ-conversion. We can replace
the whole predicate λx.¬WALK(x) (of type <e,t>) by a variable P of type <e,t>, abstract over
this variable P, and apply the result to λx.¬WALK(x):
[λx.¬WALK(x)](j)
= [λP.P(j])(λx.¬WALK(x))
[backward λ-conversion]
In this expression λP.P(j) is an expression of type <<e,t>,t> and λx.¬WALK(x) an
expression of type <e,t>.
We have shown that applying the first to the second results in an expression with the same
meaning as ¬WALK(j), hence we can add the following information to our interpretation
tree:
t ¬WALK(j)
<<e,t>,t>
<e,t> λx.¬WALK(x)
│
λP.P(j) <<e,t>,<e,t>> <e,t>
│
│
NOT
WALK
This means that we add as our lexical entry for john:
<NP,λP.P(j)>
│
john
where j  CONe, P  VAR<e,t>
We are left with finding the interpretation for the negation.
This task is exactly the same as the task we had before: we need an interpretation for NEG'
that satisfies the following equation
VPtop' = (NEG'(VPbot'))
106
Given what we know now, we need to solve the following equation:
λx.¬WALK(x) = (NEG'(WALK))
λx.¬WALK(x) is an expression that contains the negation in it, we need to write it in a form
where we have a functional expression containing the contribution of negation, which
applies to WALK.
We get that though backward λ-conversion:
we replace in λx.¬WALK(x), WALK by a variable P, abstract over that variable and apply
the result to WALK:
λx.¬WALK(x)
= [λPλx.¬P(x)](WALK)
[backward λ-conversion]
In this expression λPλx.¬P(x) is an expression of type <<e,t>,<e,t>>, which is what we were
after. We complete the tree:
t ¬WALK(j)
<<e,t>,t>
<e,t> λx.¬WALK(x)
│
λP.P(j) <<e,t>,<e,t>> <e,t>
│
│
λPλx.¬P(x)
WALK
and we add the following lexical entry:
<NEG,λPλx.¬P(x)>
│
not
where P  VAR<e,t>, x  VARe
Collecting the grammar together we get:
SYNTACTIC CATEGORIES:
NP, VP, NEG, S
TYPE ASSIGNMENT:
NP
 <<e,t>,t>
VP
 <e,t>
NEG  <<e,t>,<e,t>>
S
t
LEXICAL ENTRIES:
<NP,λP.P(j)>
where j  CONe, P  VAR<e,t>
│
john
107
where WALK  CON<e,t>
<VP,WALK>
│
walk
<NEG,λPλx.¬P(x)>
│
not
where P  VAR<e,t>, x  VARe
RULES:
R2. <NP,NP'> + <VP,VP'> ==> < S , NP'(VP')>
NP
VP
R3. <NEG,NEG'> + <VP,VP'> ==> < VP , NEG'(VP')>
NEG
VP
and we can check that we get the right interpretation by doing the derivation:
<NEG,λPλx.¬P(x)> + <VP,WALK> ==> < VP , [λPλx.¬P(x)](WALK) >
│
│
not
walk
NEG
VP
│
│
not
walk
[λPλx.¬P(x)](WALK)
= λx.¬WALK(x)
[λ-conversion]
So this is the same as:
<
VP , λx.¬WALK(x) >
NEG VP
│
│
not
walk
<NP,λP.P(j)> + < VP , λx.¬WALK(x) > ==> < S , [λP.P(j)](λx.¬WALK(x)) >
│
john
NEG VP
NP
VP
│
│
│
not walk
John NEG VP
│
│
not walk
[λP.P(j)](λx.¬WALK(x))
= [λx.¬WALK(x)](j)
[λ-conversion]
108
= ¬WALK(j)
[λ-conversion]
So we get:
<
S , ¬WALK(j) >
NP
VP
│
John NEG VP
│
│
not walk
Note that, disregarding for the moment the question of whether these interpretations are
'intuitive', they do make sense.
We interpret predicate negation as:
λPλx.¬P(x). This is an operation that takes any predicate Q and maps it onto the property
that you have iff you don't have Q.
Hence it maps WALK onto the property that you have iff you don't have the property
WALK. This is precisely what doesn't does, so it is the right interpretation for doesn't.
Also the interpretation of john as λP.P(j) makes sense.
λP.P(j) is the set of all properties that John has.
λP.P(j) (WALK) expresses that the property WALK is one of the properties in that set, hence
is one of the properties that John has, hence is a property that John has, hence John walks.
Similarly, [λP.P(j)](λx.¬WALK(x)) expresses that not walking is one of the properties in the
set of all properties that John has, which means that not walking is a property that John has,
which means that John doesn't have the property of walking, hence John doesn't walk.
Let us now look at the following example:
(2) Every girl walks.
We add to our syntax the categories N for nouns and DET for determiners and the obvious
syntactic rule:
DET + N ==> NP
We furthermore make the assumption that the type assigned to common nouns is also <e,t>,
like that assigned to VP and we assume that girl is interpreted as a constant
GIRL  CON<e,t>.
Assuming that the semantic operation corresponding to our syntactic rule is functional
application, it follows that the determiner applies as a function to the common noun. The
reason is that, whatever we decide the type of NPs to be, it is obviously not going to be t.
Thus we add to the grammar:
109
< N,GIRL>
│
girl
where GIRL  CON<e,t>
<DET,DET'> + <N,N'> ==> < NP , DET'(N')>
DET
N
The syntactic structure of every girl walks becomes:
S
NP
DET N
│
│
every girl
VP
│
walk
We argued before that the type of NPs could not be generally e, because NPs do not denote
generally individuals (quantificational NPs do not). Hence we were forced to assume that
the type of NPs is <<e,t>,t>, the type of sets of sets. Sets of sets are called generalized
quantifiers, hence <<e,t>,t> is the type of generalized quantifiers and NPs denote
generalized quantifiers.
Generalized quantifier theory hence is the theory of noun phrase interpretations.
Given that the type of NPs is <<e,t>,t>, it follows from the above rule that the type of
determiners is <<e,t>,<<e,t>,t>>.
This means that determiners are relations between sets (type <e,t>). In other words: the
determiner every in every girl walks expresses a relation between the set of girls and the set
of walkers.
Given the above considerations, the types and interpretations in our example are fixed in the
following way:
t x[GIRL(x)  WALK(x)]
<<e,t>,t>
<<e,t>,<<e,t>,t>>
│
every
<e,t> WALK
<e,t> GIRL
The topnode represents what we want the meaning of the sentence to be: i.e. whatever
semantic representation we will be able to come up with, it should be equivalent to this.
Our task now is to find the meanings of the remaining nodes: the NP and the DET. We find
110
these, again, through backward λ-conversion:
The NP meaning has to satisfy the following equation:
S' = NP'(VP')
VP' = WALK
S' = x[GIRL(x)  WALK(x)]
So:
x[GIRL(x)  WALK(x)] = NP'(WALK)
We can write x[GIRL(x)  WALK(x)] in the required format by replacing WALK by a
variable P of type <e,t>, abstracting over that variable and applying the result to WALK:
x[GIRL(x)  WALK(x)]
= [λP.x[GIRL(x)  P(x)]](WALK)
This gives us λP.x[GIRL(x)  P(x)] as the meaning of the NP every girl.
To find the meaning of every we repeat the procedure:
We know that its meaning has to satisfy the equation:
NP' = DET'(N')
NP' = λP.x[GIRL(x)  P(x)]
N' = GIRL
So we have to solve:
λP.x[GIRL(x)  P(x)] = DET'(GIRL)
As before, backward λ-conversion gives us the meaning of the DET:
Replace GIRL in λP.x[GIRL(x)  P(x)] by a variable Q of type <e,t>, abstract over that
variable and apply the result to GIRL:
λP.x[GIRL(x)  P(x)]
= [λQλP.x[Q(x)  P(x)]](GIRL)
Thus, we have solved our problem, the grammar becomes:
ADDED CATEGORIES:
DET, N
ADDED TYPE ASSIGNMENTS:
N
 <e,t>
DET  <<e,t>,<<e,t>,t>>
111
ADDED SYNTACTIC RULE
<DET,DET'> + <N,N'> ==> < NP , DET'(N')>
DET
N
ADDED LEXICAL ENTRIES:
< N,GIRL>
where GIRL  CON<e,t>
│
girl
<DET, λQλP.x[Q(x)  P(x)]>
│
every
where P,Q  VAR<e,t>, x  VARe
The meaning of every girl becomes: λP.x[GIRL(x)  P(x)]
This is the set of properties that every girl has, the set of properties that all girls share.
i.e. take a property, look whether every one of the girls has that property, if so it is in this set,
if not it is not in this set.
Thus every girl walks expresses that the property WALK is one of the properties in the set of
properties that every girl has. This of course means that every girl has that property.
We see here that what looked like a trick before, starts to become a very succesful and
general theory of noun phrase interpretation. The type <<e,t>,t> is very well suited for
interpreting all NPs. The reason is that the recipe for getting the meaning of every girl
clearly works for arbitrary NPs.
some girl, by the same procedure becomes:
λP.x[GIRL(x)  P(x)]
the set of properties that some girl has:
i.e. take a girl: all her properties are in this set. Take the next girl: all her properties are also
in this set, etc.
Moreover, the procedure applies as easily to non standard quantifiers. Look at most girls
walk. This means that more girls walk than don't.
Take a property. Look whether more than half of the girls have it, if so, put it in set X, if not,
don't put it in. Do the same for every property. The resulting set of properties X is the set of
properties that most girls have and it can function as the interpretation of most girls.
We have seen furthermore that also proper names can have a natural interpretation at this
level:
λP.P(j) is the set of all properties that j has.
Furthermore, also complex NPs can be naturally interpreted at this level. Look at John and
every girl walk. NPs of this form are Montague's prime reason to interpret John as λP.P(j)
112
rather than as j. The reason is that if John is interpreted as an expression of type e, you can't
conjoin it with the interpretation of every girl which can't be of type e.
On the other hand, if john is interpreted as a set of properties, the set of properties that John
has, not only can we conjoin it with every girl because they are of the same type, but it is also
very obvious what conjunction of two sets of properties should be: their intersection. Hence
John and every girl is interpreted as the set of properties that are shared by every girl and by
John:
λP.P(j)  x[GIRL(x)  P(x)]
and WALK is in this set iff John walks and every girl walks.
We see then that what started as a trick - the verb can't apply to a quantificational NP, so let's
switch the function-argument structure around - leads to a general theory of NP and
determiner interpretation, and the λ-operator gives us the means to easily define the
meanings of determiners and NPs within that theory.
The general theory of NP interpretations is a major achievement of Montague's work.
We've solved our problem with every girl walks, but we're not out of problems yet. We kept
<e,t> as the type of intransitive verb phrases and got out of the function argument problem
by assuming that the subject is a function on the VP. This led to assuming <<e,t>,t> as the
type of NPs. However, we now have a problem with transitive verb phrases. Transitive verb
phrases like kiss used to be of type <e,<e,t>>. But this leads to problems with our next
example:
(3) John kisses every girl.
every girl is not of type e, so it cannot be the argument of kiss if that is of type <e,<e,t>>.
This time, however, we cannot without cost just switch the function-argument structure
around. If we assume that every girl is a function that takes the meaning of kiss as an
argument, then every girl will have type <<e,<e,t>>,<e,t>>. But that is incompatible with
the Fixed Type Assignment assumption, because now we have to give a different
interpretation to the NP when it is an object from when it is a subject.
This means that we cannot let transitive verbs be of the type <e,<e,t>> and assume that
combining a TV with an object NP is functional application. Keeping the latter assumption
leads to the following rule:
< TV,TV'> + <NP,NP'> ==> < VP , TV(NP) >
TV
NP
Given that the type for VP is <e,t> and for NP is <<e,t>,t>, this means that the type assigned
to TV is <<<e,t>,t>,<e,t>>.
Hence transitive verb phrases like kiss are interpreted as relations between individuals and
sets of properties.
As before we can express that in the grammar by assuming a lexical entry of the following
type:
113
<TV,KISS>
│
kiss
where KISS  CON<<<e,t>,t>,<e,t>>
Let T  VAR<<e,t>,t> and x  VARe.
In relational notation this means that we interpret kiss as:
λTλx.KISS(x,T)
the relation that holds between an individual and a set of properties iff that individual
and that set stand in the relation KISS.
The problem is as before that we have here a relation between an individual and a set of
properties, and nothing is yet said about how this relation relates to the intuitive relation of
kissing between individuals. That is, all sorts of logical inferences that should hold are not
accounted for.
Using this as the meaning of kiss, we get as the meaning of John kisses Mary:
KISS(j,λP.P(m))
the relation KISS holds between John and the set of all of Mary's properties.
This representation does not guarantee that any kissing goes on between the individuals John
and Mary.
The meaning of John kisses every girl becomes:
KISS(j,λP.z[GIRL(z)  P(z)])
the relation KISS holds between John and the set of properties that all girls share.
The problem is that the inference from (3) and (4) to (5) should obviously follow from the
semantics:
(3)
(4)
(5)
John kisses every girl.
Mary is a girl.
John kisses Mary.
The problem is that even this is not guaranteed. The inference from (3') and (4') to (5') is not
valid in type logic.
(3')
(4')
(5')
KISS(j,λP.z[GIRL(z)  P(z)])
GIRL(m)
KISS(j,λP.P(m))
As before, the problem is that making KISS a constant of type <<<e,t>,t>,<e,t>> does not by
itself relate it to actual kissing, the relation that holds between two individuals if the first
kisses the second, denoted by the relation KISS  CON<e,<e,t>>.
What we want to do, then, is define the interpretation of the transitive verb, in terms of the
114
latter relation.
So, let us assume that KISS  CON<e,<e,t>>
The syntactic structure of John kisses every girl is as follows:
S
NP
VP
│
John TV
NP
│
kiss DET N
│
│
every girl
The type structure and semantic interpretations as far as we know them are as follows:
t z[GIRL(z)  KISS(j,z)]
<<e,t>,t> λP.P(j)
<e,t> ?
<<e,t>,t> λP.z[GIRL(z)  P(z)]
<<<e,t>,t>,<e,t>> ?
<<e,t>,<<e,t>,t>>
λQλP.z[Q(z)  P(z)]
<e,t>
GIRL
We start by looking for the interpretation for the VP kiss every girl.
We have to solve the following equation:
S' = NP'(VP')
S' = z[GIRL(z)  KISS(j,z)]
NP' = λP.P(j)
So:
z[GIRL(z)  KISS(j,z)] = [λP.P(j)](VP')
Let us first, to be precise, undo the relational notation in the sentence:
z[GIRL(z)  KISS(j,z)]
= z[GIRL(z)  [KISS(z)](j)]
[functional notation]
Next we λ-convert j out:
= [λx.z[GIRL(z)  [KISS(z)](x)]](j)
[backward λ-conversion]
115
Next we convert the whole predicate λx.z[GIRL(z)  [KISS(z)](x)] out:
= [λP.P(j)](λx.z[GIRL(z)  [KISS(z)](x)])
[backw. λ-con.]
This means that we have found the meaning of the VP kiss every girl:
λx.z[GIRL(z)  [KISS(z)](x)]
the property that you have if you kiss every girl.
We add it to the semantic tree (for clarity with KISS back in relational notation):
t z[GIRL(z)  KISS(j,z)]
<e,t> λx.z[GIRL(z)  (KISS(x,z)]
<<e,t>,t> λP.P(j)
<<e,t>,t> λP.z[GIRL(z)  P(z)]
<<<e,t>,t>,<e,t>> ?
<<e,t>,<<e,t>,t>>
λQλP.z[Q(z)  P(z)]
<e,t>
GIRL
Our next task then is to solve the following equation:
VP' = TV'(NP')
VP' = λx.z[GIRL(z)  [KISS(z)](x)]
NP' = λP.z[GIRL(z)  P(z)]
So:
λx.z[GIRL(z)  [KISS(z)](x)] = TV'(λP.z[GIRL(z)  P(z)])
We solve this problem in the same way as before, except that this time it is much more
difficult.
We start with:
λx.z[GIRL(z)  [KISS(z)](x)]
We know that we have to bring this in a form where the whole NP meaning of every girl
λP.z[GIRL(z)  P(z)] is the argument of some function.
If we can turn the above expression into an expression that has this NP meaning as a subexpression, we can convert it out, and we have solved out problem.
So we are going to turn the above expression into an expression that has
λP.z[GIRL(z)  P(z)] as a sub-expression.
We do have z[GIRL(z)  [KISS(z)](x)] as a sub-expression.
We would like to do backward λ-abstraction, by abstracting out a property of type <e,t>,
because that would give us the abstraction over variable P. However, we cannot do that in
this expression, because the only property expression we have in the consequent of this
116
conditional is KISS(z). If we abstract that out, we would get:
λP.z[GIRL(z)  P(x)] (KISS(z))
In this way we have indeed turned z[GIRL(z)  [KISS(z)](x)] into an expression with an
NP meaning as a sub-expression:
λP.z[GIRL(z)  P(x)] (KISS(z))
but, unfortunately, not with the right NP meaning as a sub-expression, because we wanted to
have λP.z[GIRL(z)  P(z)] and we got λP.z[GIRL(z)  P(x)].
Now we have localized our problem.
(KISS(z))(x) is at the moment in a form where a property KISS(z) applies to x. We want to
bring this into a form where a property applies to z.
This we can do with backward λ-conversion.
[KISS(z)](x)
= [λy.[KISS(y)](x)](z)
[backward λ-conversion of z]
This means that we can replace the sub-expression [KISS(z)](x)
in λx.z[GIRL(z)  [KISS(z)](x)] by [λy.[KISS(y)](x)](z)
This means that:
λx.z[GIRL(z)  [KISS(z)](x)]
= λx.z[GIRL(z)  [λy.[KISS(y)](x)](z) ]
Now look in the latter at the sub-expression:
z[GIRL(z)  [λy.[KISS(y)](x)](z) ]
In this expression we have [λy.[KISS(y)](x)] as a sub-expression, hence we can apply
backward λ-conversion to it and get:
z[GIRL(z)  [λy.[KISS(y)](x)](z) ]
= [λP.z[GIRL(z)  P(z)]](λy.[KISS(y)](x))
[backward λ-conversion of λy.[KISS(y)](x) ]
This means that in λx.z[GIRL(z)  [λy.[KISS(y)](x)](z) ]
we can replace the sub-expression:
z[GIRL(z)  [λy.[KISS(y)](x)](z) ] by:
[λP.z[GIRL(z)  P(z)]](λy.[KISS(y)](x))
This means that:
λx.z[GIRL(z)  [λy.[KISS(y)](x)](z) ]
117
= λx.[λP.z[GIRL(z)  P(z)]](λy.[KISS(y)](x))
Now we have λP.z[GIRL(z)  P(z)] as a sub-expression. We can convert it out, by
replacing it by a variable T  VAR<<e,t>,t> and abstracting over T and applying the result to
λP.z[GIRL(z)  P(z)]:
λx.[λP.z[GIRL(z)  P(z)]](λy.[KISS(y)](x))
= [λTλx.T(λy.[KISS(y)](x))](λP.z[GIRL(z)  P(z)])
Hence we have found TV':
TV' = λTλx.T(λy.[KISS(y)](x))
or in relational notation:
TV' = λTλx.T(λy.KISS(x,y))
This is of the right type <<<e,t>,t>,<e,t>>, so we can complete the grammar with the
following lexical item:
<TV, λTλx.T(λy.KISS(x,y))> where KISS  CON<e,<e,t>>, T  VAR <<e,t>,t>, x,y  VARe
│
kiss
Now, all this looks very difficult and complicated. So what if we can find a complicated
translation of kiss that does what Montague wants it to do? It looks pretty unreadable as it is.
Solving this problem is actually a major achievement of Montague's work. The problem that
is solved here is not restricted to the particular semantic theory developed here.
Every semantic theory for the interpretation of NPs will have to be a theory of the
interpretation of non-quantification NPs and quantificational NPs (for one thing, because we
can conjoin them). Hence every such theory is faced with the problem of what to do with
NPs as the objects of transitive verbs, and hence with the problem of what to do with
transitive verbs.
The observation is that, though syntactically the object of a(n extensional) TV is in the scope
of that TV, semantically it takes scope over the TV. This can be seen with quantificational
objects:
(3)
(6)
(7)
John kisses every woman.
x[WOMAN(x)  KISS(j,x)]
KISS is in the scope of EVERY WOMAN.
John kisses some woman.
x[WOMAN(x)  KISS(j,x)]
KISS is in the scope of SOME WOMAN.
John kisses no woman.
¬x[WOMAN(x)  KISS(j,x)]
118
KISS is in the scope of NO WOMAN.
Exactly the same shows up with operations: syntactically john and bill and john or bill are in
the scope of kiss, semantically the conjunction and disjunction take scope over KISS:
(8)
(9)
Henry kisses John and Bill.
KISS(h,j)  KISS(h,b)
or in scopal notation: (KISS(h,j),KISS(h,b))
Henry kisses John or Bill.
KISS(h,j)  KISS(h,b)
in scopal notation: (KISS(h,j),KISS(h,b))
This fact is exactly what Montague's interpretation captures.
kiss is interpreted as λTλx.T(λy.KISS(x,y)).
If we apply this to a quantificational NP like no woman:
λP.¬z[WOMAN(z)  P(z)], this NP meaning will enter for the variable T and take,
semantically, scope over KISS.
Similarly, john or bill interpreted as: λP.P(j)  P(b) will be λ-converted into the T-place,
giving:
λx.[λP.P(j)  P(b)](λy.KISS(x,y))
Here the conjunction has scope over KISS, which becomes clear in the next λ-convertion:
λy.KISS(x,y) is converted for both P's under the scope of conjunction and further convertions
give indeed:
λx.KISS(x,j)  KISS(x,b)
Thus, this interpretation for transitive verbs solves the problem of quantificational objects,
and solves it by letting the meaning of the TV kiss express that its object will take scope
over the relation KISS.
All that the complex interpretation expresses is this, and nothing more than this.
That it works generally for all NPs can be seen once we understand what the interpretation
really means.
kiss is interpreted as λTλx.T(λy.KISS(x,y)). Let us call this relation K. K is a relation
between individuals and sets of properties.
If you are x then λy.KISS(x,y) expresses the property of BEING KISSED BY YOU.
K then is the relation that you stand in to a set of properties iff the property of BEING
KISSED BY YOU is in that set.
-You stand in relation K to the set of John's properties
iff the property of BEING KISSED BY YOU is in the set of John's properties
iff you kiss John.
119
-You stand in relation K to the set of properties that every girl has
iff the property of BEING KISSED BY YOU is in the set of properties that every girl has
iff you kiss every girl.
-You stand in relation K to the set of properties that no girl has
iff the property of BEING KISSED BY YOU is in the set of properties that no girl has
iff you kiss no girl.
Now that we have solved this problem, let us look at the type of VPs. We have assumed that
VP's are of type <e,t> and that the subject applies as a function to the verb. There may be
reasons why we would want the verb to apply as a function to the subject, just as it applies as
a function to the object.
Keeping the assumption that NPs are generalized quantifiers, this means that VP's can no
longer be of type <e,t>, but have to be of type <<<e,t>,t>,t>. If we do that, we have to find
an interpretation of type <<<e,t>,t>,t> for intransitive verbs, and the same considerations as
for transitive verbs, lead to the conclusion that for an intransitive verb like walk we want to
define the interpretation of walk at type <<<e,t>,t>,t> in terms of the basic predicate WALK
of type <e,t>.
It is not difficult to see what this interpretation should be.
Before we interpreted john walks as:
[λP.P(j)](WALK)
We need to solve the following equation:
[λP.P(j)](WALK) = VP'(λP.P(j))
Backward λ-convertion on λP.P(j) does exactly that:
[λP.P(j)](WALK) =
[λT.T(WALK)](λP.P(j))
where T  VAR<<e,t>,t>
Hence such a theory would change the grammar to:
VP
 <<<e,t>,t>,t>
<NP,NP'> + <VP,VP'> ==> < S , VP'(NP') >
NP
<VP,λT.T(WALK)>
│
walk
VP
where WALK  CON<e,t> and T  VAR<<e,t>,t>
120
4.2. Cross categorial negation, conjunction and disjunction.
We have already discussed examples of negation, conjunction and disjunction at other types
besides t.
We discussed predicate negation, conjunction and disjunction, and showed that we could
define not walks, walk and talk, walk or talk as:
λx.¬WALK(x)
λx.WALK(x)  TALK(x)
λx.WALK(x)  TALK(x)
Consequently, writing [<e,t>], [<e,t>], [<e,t>] for predicate negation, predicate conjunction
and predicate disjunction respectively, we can -with backward λ-conversion define:
Let P,Q  VAR<e,t> and x  VARe.
[<e,t>] = λPλx.¬P(x)
[<e,t>] = λQλP.P(x)  Q(x)
[<a,t>] = λQλP.P(x)  Q(x)
Similarly, we discussed conjunction of two place relations; negation and disjunction are
similar, hence we have:
λyλx.¬[KISS(y)](x)
λyλx.[KISS(y)](x)  [HUG(y)](x)
λyλx.[KISS(y)](x)  [HUG(y)](x)
Or in relational notation:
λyλx.¬KISS(x,y)
λyλx.KISS(x,y)  HUG(x,y)
λyλx.KISS(x,y)  HUG(x,y)
Writing [<e,<e,t>>] for relation negation, etc., we can define with backward λ-conversion:
Let R,S  VAR<e,<e,t>> and x,y  VARe
[<e,<e,t>>] = λRλyλx.¬[R(y)](x)
[<e,<e,t>>] = λSλRλyλx.[R(y)](x)  [S(y)](x)
[<e,<e,t>>] = λSλRλyλx.[R(y)](x)  [S(y)](x)
We discussed conjunction of NPs at type <<e,t>,t>; again, negation and disjunction are
similar. We get for not john, john and mary, john or mary:
λP.¬[λQ.Q(j)](P)
λP.[λQ.Q(j)](P)  [λQ.Q(m)](P)
λP.[λQ.Q(j)](P)  [λQ.Q(m)](P)
121
Which reduce further to:
λP.¬P(j)
λP.P(j)  P(m)
λP.P(j)  P(m)
Writing [<<e,t>,t>] for NP negation, etc., we can define:
Let T,U  VAR<<e,t>,t> and P  VAR<e,t>
[<<e,t>,t>] = λTλP.¬T(P)
[<<e,t>,t>] = λUλTλP.T(P)  U(P)
[<<e,t>,t>] = λUλTλP.T(P)  U(P)
These definitions are based on the observation that in all these types we find not, and and or
with essentially the same meaning that negation, conjunction and disjunction have at type t.
This does not mean that and always has a meaning that is related to sentential conjunction.
For instance, neither the NP conjunction and, nor the predicate conjunction and in the next
example are of that nature:
(1) John and Mary are husband and wife.
The NP conjunction in (1) isn't the and we have defined, because (1) is not equivalent to (2):
(2) John is husband and wife and Mary is husband and wife.
The predicate conjunction in (2) isn't the and we have defined, because (1) is also not
equivalent to (3):
(3) John and Mary are wife and husband.
So, we're not claiming that all instances of and are definable in terms of conjunction at type
t. But we are claiming that at all these types we do find an operation and which is.
There are many more types at which we find these operations: negation, conjunction and
disjunction appear cross-categorially.
Also, when we look at the above definitions, it seems clear that they all follow a similar
schema.
For this reason we would like to define these operations once and for all for all the types at
which they occur.
In all the cases that we have studied so far, we see that the type at which we define negation,
conjunction and disjunction is related to type t in a particular way.
In all these cases we observe the following relation between the type a at which we want to
define the operations and type t:
When we look at the tree that represents how the type is built up, we systematically find that
the most rightward type is type t:
122
Let TREE[a] be the construction tree for type a.
TREE[t] = t
Obviously t is the rightmost type in this tree.
TREE[<e,t>] =
<e,t>
e
TREE[<e,<e,t>>] =
t
<e,<e,t>>
e
<e,t>
e
TREE[<<e,t>,t>] =
t
<<e,t>,t>>
<e,t>
e
t
t
The same holds for other types where we may want to define these operations. For instance
determiners:
TREE[<<e,t>,<<e,t>,t>>] =
<<e,t>,<<e,t>,t>>
<e,t>
e
<<e,t>,t>>
t
<e,t>
e
t
t
And modifiers:
TREE[<<e,t>,<e,t>>] =
<<e,t>,<e,t>>
<e,t>
e
<e,t>
t
e
t
Such types are called boolean types, because all of them can be given the form of a boolean
algebra (which means just the same as that on all of them we can define negation,
conjunction and disjunction with exactly the same properties as negation, conjunction and
disjunction have at type t).
The set of boolean types, BOOL, can be defined in the following way:
123
BOOL is the smallest subset of TYPE such that:
1. t  BOOL
2. if a  TYPE and b  BOOL then <a,b>  BOOL
It can be checked in the above trees that all the types given are indeed boolean types. Types
that are not boolean are, for instance: e, <t,e>, <<e,t>,e>, <<e,e>,<e,e>>.
What we want to do now is define [a], [a], [a] for all boolean types a.
We will define these recursively following the recursive definition of boolean types.
We will first define [t], [t] and [t].
Then we will show how, assuming that we have defined [b], [b], [b] for boolean type b, we
can define in terms of that [<a,b>], [<a,b>], [<a,b>] for boolean type <a,b>. If we manage to
do that, we have indeed defined [a], [a], [a] for all boolean types.
The following definition does exactly that.
1. Base step.
Let φ,ψ  VARt:
[t] = λφ.¬φ
[t] = λψλφ.φ  ψ
[t] = λψλφ.φ  ψ
1. Recursive step.
Let P,Q  VAR<a,b> and x  VARa:
[<a,b>] = λPλx.[b](P(x))
[<a,b>] = λQλPλx.[[b](Q(x))](P(x))
[<a,b>] = λQλPλx.[[b](Q(x))](P(x))
We can write this also in infix notation for clarity:
[<a,b>] = λPλx.[b](P(x))
[<a,b>] = λQλPλx.P(x) [b] Q(x)
[<a,b>] = λQλPλx.P(x) [b] Q(x)
Note: we are assuming in this definition that the variables P and x are new, in the sense that
they do not already occur in [b], [b] or [b].
Examples:
124
Let P,Q  VAR<e,t>, R,S  VAR<e,<e,t>>, T,U  VAR<<e,t>,t>,
x,y  VARe
[<e,t>]
= λPλx.[t](P(x))
[t] = λφ.¬φ
Hence:
[<e,t>]
= λPλx.[t](P(x))
= λPλx.[λφ.¬φ](P(x))
= λPλx.¬P(x)
[def [<e,t>]]
[def [t]]
[λ-conversion]
[<e,t>]
= λQλPλx.[[t](Q(x)](P(x)
= λQλPλx.[[λψλφ.φ  ψ](Q(x)](P(x))
= λQλPλx.[λφ.φ  Q(x)](P(x))
= λQλPλx.P(x)  Q(x)
[def [<e,t>]]
[def [t]]
[λ-con]
[λ-con]
[<e,<e,t>>]
= λRλy.[<e,t>](R(y))
= λRλy[λPλx.¬P(x)](R(y))
= λRλyλx.¬[R(y)](x)
= λRλyλx.¬R(x,y)
[def [<e,<e,t>>]]
[see above]
[λ-con]
[rel notation]
In this derivation we see what we meant by choosing new variables: we choose a variable y
in the first step, because variable x of the same type already occurs in the definition of
[<e,t>].
[<e,<e,t>>]
= λSλRλy.[[<e,t>](S(y))](R(y))
= λSλRλy.[[λQλPλx.P(x)  Q(x)](S(y))](R(y))
= λSλRλy.[λPλx.P(x)  [S(y)](x)](R(y))
= λSλRλyλx.[R(y)](x)  [S(y)](x)
= λSλRλyλx.R(x,y)  S(x,y)
[<<e,t>,t>]
= λTλP.[t](T(P))
= λTλP.[λφ.¬φ](T(P))
= λTλP.¬T(P)
[def [<e,<e,t>>]]
[see above]
[λ-con]
[λ-con]
[rel. notation]
[def [<<e,t>,t>]]
[def [t]]
[λ-con.]
In fact, it is obvious that this derivation is exactly the same as the above derivation of [<e,t>]
but with variable T substituted for P and variable P substituted for x.
125
The same substitution of T for P, U for Q, P or x in the derivation of [<e,t>] gives the
derivation of [<<e,t>,t>] = λUλTλP.T(P)  U(P)
We see that this general definition will indeed produce the correct definition of negation,
conjunction and disjunction at all the boolean types.
In practice, this definition is rather cumbersome and there is a much shorter way of getting
the right definition.
We can read the proper definition of negation at type a off the construction tree for type a,
TREE[a].
We will associate with every node of the right-edge of TREE[a] a formula-construction box.
A formula construction box for negation looks like this:
[α│β]
for conjunction and disjunction it looks like this:
[α│β;δ]
In a construction box, α is a λ-prefix, i.e. α is of the form λx1...λxn. and β, δ are expressions.
Here are the instructions for associating construction boxes for negation and conjunction
with nodes in TREE[a]:
1. We start at the topnode of TREE[a].
Choose variables P and Q of this type and associate with this node the construction boxes:
[ λP. │ P ]
[ λQλP. │ P ; Q ]
(for negation)
(for conjunction)
2. Go to the daughters of node a.
-if there aren't any, then a was t, and you stop.
- if the daughters are b and c (i.e. a = <b,c>) you do the following:
Choose a variable x of type b that doesn't yet occur in the construction boxes of node a, and
associate with node c the following construction boxes:
[ λPλx. │ (P(x))
]
[ λQλPλx. │ (P(x)) ; (Q(x)) ]
So we get the following tree:
126
a [ λP. │ P ]
[ λQλP. │ P ; Q ]
b
c [ λPλx. │ (P(x))
]
[ λQλPλx. │ (P(x)) ; (Q(x)) ]
3. Go to the daughters of node c.
- if there aren't any, stop.
- otherwise, repeat the procedure:
In general if the mothernode is x, and the daughter nodes y and z, (i.e. x = <y,z>) and the
construction boxes of the mother node x are:
[ X. │ α ]
[ Y. │ α ; β ]
you choose a variable P of type y, and add to node z the construction boxes:
[ XλP. │ (α(P))
]
[ XλP. │ (α(P)) ; (β(P)) ]
This procedure ends when you reach type t at the right end bottom of the tree.
There you define [a], [a] and [a] on the construction boxes that you get there:
Suppose these are:
[ X. │ α ]
[ Y. │ α ; β ]
Then:
[a] = X.¬α
[a] = Y.α  β
[a] = Y.α  β
127
EXAMPLES
In the following examples, I will diverge only from the above procedure in that I may leave
out some brackets, when I feel like it (and introduce them again later if necessary).
TREE[t]
φ,ψ
t
[ λφ. │ φ ]
[ λψλφ. │ φ ; ψ ]
[t] = λφ.¬φ
[t] = λψλφ.φ  ψ
TREE[<e,t>]
<e,t> [ λP. │ P ]
[ λQλP. │ P ; Q ]
P,Q
x
e
t [ λPλx. │ P(x)
]
[ λQλPλx. │ P(x) ; Q(x) ]
[<e,t>] = λPλx.¬P(x)
[<e,t>] = λQλPλx.P(x)  Q(x)
TREE[<e,<e,t>>]
<e,<e,t>> [ λR. │ R ]
[ λSλR. │ R ; S ]
R,S
y
x
e
<e,t> [ λRλy. │ R(y)
]
[ λSλRλy. │ R(y) ; S(y) ]
e
t [ λRλyλx. │ [R(y)](x)
]
[ λSλRλyλx. │ [R(y)](x) ; [S(y)](x) ]
[<e,<e,t>>] = λRλyλx.[R(y)](x)
[<e,<e,t>>] = λSλRλyλx.[R(y)](x)  [S(y)](x)
128
TREE[<<e,t>,t>]
T,U
<<e,t>,t>> [ λT. │ T ]
[ λUλT. │ T ; U ]
P
<e,t>
e
t [ λTλP. │ T(P)
]
[ λUλTλP. │ T(P) ; U(P) ]
t
[<<e,t>,t>] = λTλP.¬T(P)
[<<e,t>,t>] = λUλTλP.T(P)  U(P)
TREE[<<e,t>,<<e,t>,t>>] =
X,Y
<<e,t>,<<e,t>,t>> [ λX. │ X ]
[ λYλX. │ X , Y ]
Q
<<e,t>,t>> [ λXλQ.│ X(Q)
]
[ λYλXλQ.│ X(Q) ; Y(Q) ]
<e,t>
e
t
P
t [ λXλQλP. │ [X(Q)](P)
]
[ λYλXλQλP. │ [X(Q)](P) ; [Y(Q)](P)]
<e,t>
e
t
[<<e,t>,<<e,t>,t>>] = λXλQλP.¬[X(Q)](P)
[<<e,t>,<<e,t>,t>>] = λYλXλQλP.[X(Q)](P)  [Y(Q)](P)
TREE[<<e,t>,<e,t>>] =
<<e,t>,<e,t>> [ λA. │ A ]
[ λBλA. │ A ; B ]
A,B
P
<e,t>
e
x
<e,t> [ λAλP. │ A(P)
]
[ λBλAλP. │ A(P) ; B(P) ]
t
e
t [ λAλPλx. │ [A(P)](x)
]
[ λBλAλPλx. │ [A(P)](x) ; [B(P)](x) ]
[<<e,t>,<e,t>>] = λAλPλx.¬[A(P)](x)
[<<e,t>,<e,t>>] = λBλAλPλx.[A(P)](x)  [B(P)](x)
129