Semantics I

lambda-notation for functions, informal lambda calculus,

quantification
Benjamin Spector
Class 4 - Spring 2020

1 Lambda notation for functions, notions of typed lambda-calculus

1 A notation for functions
.
A lambda term has the following form:
(1) [λ Xτ .Φ], where Φ is an expression.
For ease of reading, I will sometimes omit the brackets and simply write λ Xτ .Φ.

Typically, the expression Φ contains the variable X.1 The subscript τ indicates the type of the variable X. You can
think of (1) as representing the function which, when applied to an object denoted by o of type τ, returns the result
of computing the expression Φ after having replaced all occurrences of X by o.
So, for instance, the function λ x.x + 3, when applied to the number 7, returns 7 + 3. You can think of this last
lambda term as an alternative notation for the function f (x) = x + 3.

So suppose we have the function i(sleep) described above, and another function for i(snore) (both of type
< e,t >).

Then we can think of the denotation of snores and sleeps as being the following function:
(2) λ xe .min(i(sleeps), i(snores))
This is function from individuals to truth-values which maps an individuald d to 1 just in case i(sleeps)(d) = 1 and
i(snores)(d)= 1.

Since (2) denotes a function from objects of type e to truth-values, it is itself a function of type < e,t >.

We will rewrite this as

(3) λ xe .i(sleeps)∧i(snores)
(think of ∧ as a metalanguage conjunction, whose meaning is just ‘min’: when x and y are truth-values,
x ∧ y = min(x, y)).
Our rule for coordinated VPs becomes:
 M
VP
(4)   =λ x. [[VP1 ]]M (x) ∧ [[VP2 ]]M (x)
VP1 and VP2
We will also adopt, from now on, the following convention. Instead of writing i(sleeps), we will use the word in
boldface to denote its denotation (but it’s of course relative to a model, which we should not forget!). That is, we
will write things like:
1 If the variable in the lambda prefix does not occur in Φ, then the lambda term denotes a constant function which maps every possible

argument to whatever Φ means. For instance, λ x.7 might be thought of as the function that maps everything to the number 7.

1
(5) a. [[snores]]M = λ xe .snores(x)
b. [[sleeps]]M = λ xe .sleeps(x)
 M
VP
 M  M



 VP VP
 
 VP and VP     
c.   = λ xe . 


 V

 (x)∧

 V  (x) = . . . = λ xe .snores(x)∧sleeps(x)

     
 V V 
 
  snores sleeps
snores sleeps

2 Reduction
When one applies a lambda term to an object o, we generally can get rid of the first lambda-prefix and replace
every occurrence of the variable introduced by λ with the symbol for the object o. This is called reduction.2 We
need the argument to be of the right type, i.e. to be the type of the variable of the first λ .
(6) Well-formedness rule
An expression of the form [λ Xτ .Φ](α) is well-formed only if α is of type τ.
Example:
(7) [[snores and sleeps]]M (a) = [λ xe .snores(x) ∧ sleeps(x)](a) = snores(a) ∧ sleeps(a)

The expression on the right denotes 1 just un case i(snores)(a) = 1 and i(sleeps)(a) = 1.
Consider now the function:
(8) λ ye .λ xe .looks at(y)(x) ∧ listens to(y)(x)
This is a function of type < e, < e,t >>. You can think of it as being the denotation of regarde and écoute, in a
sentence such as Christian regarde and écoute Béatrice.

Let us apply the function described in (8) to some object b. This amounts to reducing the expression on the
first line of (9), by eliminating λ y. and replacing all occurrences of y with b.
(9) [λ y.λ x.looks at(y)(x) ∧ listens to(y)(x)](b)
= λ x.looks at(b)(x) ∧ listens to(b)(x)
This new lambda term itself represents a function of type < e,t >. Now we can see what happens when we apply
this to c. We get:
(10) [λ y.λ x.looks at(y)(x) ∧ listens to(y)(x)](b)(c)
= [λ x.looks at(b)(x) ∧ listens to(b)(x)](c)
= looks at(b)(c) ∧ listens to(b)(c)
Note that the following always hold:
(11) snores<e,t> = λ x.snores(x)
The expressions on the two sides of the equality sign in (11) denote the same function: the function that maps an
individuald x to 1 just in case snores(x) = 1, which is simply the function snores.

So we will sometimes write things like

(12) a. [[snores]]M = λ x.snores(x)
b. [[regarde]]M = λ y.λ x.looks at(y)(x)
Let us see again how semantic composition works when we use the lambda notation. Let us start with the following
tree.
2 If the variable in the lambda prefix does not occur in Φ, there is no remplacement to make and the lambda term denotes a constant

function which maps every possible argument to the value of Φ, cf. previous footnote.

2
 St

NPe VP<e,t>

Ne

Christiane
VP<e,t> and VP<e,t>

V
V<e,<e,t>> NPe
sleeps<e,t>
regarde<e,<e,t>> N

Béatricee
Let us now replace the terminal nodes with their denotation (assuming Béatrice denotes b, and Christian c):
St

NPe VP<e,t>

Ne

c
VP<e,t> and VP<e,t>

V<e,t>
V<e,<e,t>> NPe
λ xe .sleeps(x)
λ y.λ x.looks at(y)(x) N

b
We can then use functional application and reduction to get a denotation for the VP regarde Béatrice, apply
our rule for VP coordination (in (4)), and then for the whole sentence. We write the results of these operations on
the corresponding nodes, simplifying the tree when we have nodes that dominate a unique node, and writing on
every terminal node and intermediate node a denotation

sleeps(c) ∧ looks at(b)(c)

c λ xe .sleeps(x) ∧ looks at(b)(x)

λ xe .sleeps(x) and λ x.looks at(b)(x)

λ y.λ x.looks at(y)(x) b

3 Constraints on reduction, free and bound variables, variable renaming

When a lambda term λ X.Φ is applied to an argument α, one can eliminate the lambda-prefix and replace the
occurrences of X in Φ with α, but with some constraints. Let us illustrate with an example:
(13) λ ye .λ xe .looks at(y)(x)

3
Suppose we now want to apply this function to an object named x, and we replace all occurrences of y with x. We
would get:
(14) Incorrect reduction:
[λ ye .λ xe .looks at(y)(x)](x) = λ xe .looks at(x)(x)
Intuitively, the expression in (13) denotes the relation looks at. When we give it the argument x, we want the result
to be the property looks at-x. However, what we derived in (14) is rather something like looks at-oneself : it is the
function that maps x to 1 just in fact x is in the relation looks at to x itself.

What went wrong is that we used as an argument a symbol which also occurred in a lambda prefix. To avoid
such problems, a solution that always works is to rename the variables used in the lambda-prefixes (and then
rename all the occurences of variables that depend on this lambda-prefix), so that the argument a lambda-term
takes does not correspond to a lambda-prefix occurring within the lambda-term. That is, instead of (14), we add
an intermediate step where we rename the variable x in the lambda term, changing it into z.
(15) [λ ye .λ xe .looks at(y)(x)](x)=
[λ ye .λ ze .looks at(y)(z)](x)= λ ze .looks at(x)(z)
For those who are formally inclined [this is entirely optional at this point]:
(16) An occurrence of a variable x is bound in an expression Φ if this occurrence occurs in a lambda-term
which is a subexpression of Φ and whose lambda prefix is λ x. An occurrence of a variable x is free in an
expression Φ if it is not bound in Φ.
A first constraint is that when we reduce [λ Xτ .Φ](a), we eliminate λ Xτ and replace an occurrence of X in Φ with
a, but only if this occurrence is free in Φ.3

The operation of reduction (called beta-reduction) must not turn a free variable in Φ into a bound variable, and
it should not turn either a bound variable into a free variable. The problem in (14) is that the variable y is free in
λ xe .looks at(y)(x), but when we replace if with x it becomes bound.

In this class we are using lambda-terms and use them to compute the result of functional application in a semi-
formal way, just as a convenient tool. As long as we remember what functions the lambda-terms describe, and are
careful in the way illustrated above when we perform reduction, we won’t run into problems – which is why I am
not providing here a formal definition of ‘reduction’.

What is important from our point of view: an expression E (in our metalanguage) and its beta-reduced form
have the same meaning. That is, these two expressions denote exactly the same < e,t > function:
(17) a. [λ ye .λ xe .looks at(y)(x)](a)
b. [λ xe .looks at(a)(x)]
c. Informally: the characteristic function of the individuals who look at a.
3 This takes care of ‘pathological’ cases where the same variable occurs in several lambda-prefixes as in:

(i) λ xe .λ xe .P(x, x)

Consider how reduction words in this case:

(ii) [λ xe .λ xe .P(x, x)](a)

We eliminate the first λ xe , and then replace every occurrence of x that is free in λ xe .P(x, x) with a. However, no occurrence of x is free in
λ xe .P(x, x), so we do no replacement at all, and we end up simply with λ xe .P(x, x). In other words, the above expression denotes a constant
function that maps every individual to the function λ xe .P(x, x). This lambda term is equivalent to:

(iii) [λ ye .λ xe .P(x, x)](a)

A good practice is simply to avoid writing things such as (ii), and to use different variables in each lambda prefix, which sometimes might
involve renaming variables.
When we mix the lambda notation with first order logic (as we’ll soon do), a similar case arises with:

(iv) λ x.∀xP(x)

The variable x is not free in ∀xP(x), as it is bound by ∀x, so can not be targeted by replacement when we perform reduction.

4
4 Exercises
Question 1
Let M be a model whose domain is D = {a, b, c, d}
Suppose that a, b, c, d are the denotations of, respectively Anne, Béatrice, Christian and David
Suppose that we want our model to represent a situation where:
(1) a. Everybody is looking at Anne
b. Christian is looking at himself and Anne but at nobody else, and nobody else is looking at Christian.
c. Béatrice and David looks at each other, and at nobody else except Anne.
d. Anne looks at Béatrice and at nobody else

1. Give the set of all ordered pairs < x, y > such that x is looking at y.

2. Based on this, describe the function of type < e, < e,t >> that must be the denotation of regarde in M,
given the constraints in (1).

Question 2 – Lambda calculus

Assume that b is an individual (type e), and snores and sleeps are functions of type < e,t >.
(2) Are the following expressions well-formed? If so, reduce the expression as much as you can.
a. [λ xe .sleeps(x)](λ ye .snores(y))
b. [λ xe .sleeps(x)](b)
c. [λ P<e,t> .λ xe .P(x)](snores)(b)
d. [λ P<e,t> .λ xe .P(x)](snores(b))
e. [λ P<e,t> .λ xe .P(x) ∧ sleeps(x)](snores)(b)
f. [λ P<e,t> .λ xe .P(x) ∧ sleeps(x)](b)(snores)
g. [λ P<e,t> .λ xe .P(x) ∧ sleeps(x)](snores)
h. [λ xe .λ P<e,t> .P(x) ∧ sleeps(x)](b)(snores)
i. [λ xe .λ P<e,t> .P(x) ∧ sleeps(x)](snores)(b)
Question 3
Our fragment does not include negation. Let us assume that the French negation ne . . . pas, which has a quite
complex syntax, is interpreted as a single operator noted NEG that combines with the VP to create a bigger VP.
That is we analyse Paul ne regarde pas Isabelle as having the following structure:

NP VP

N
NEG VP
Pierre
Vtr NP

regarde N

Isabelle
– Given that we want all VPs to be of type < e,t >, and we want NEG to compose with its sister by means
of function application, what must be the type of NEG?
– Suggest a denotation for NEG, using the lambda notation. You can use the symbol ¬ in the metalanguage, as
representing the function that maps 0 to 1 and 1 to 0, so that, for instance ¬sleeps(x) = 1 iff sleeps(x) = 0 (a
compact way to describe ¬ is as follows: ¬x = 1 − x, where x takes its value in {0, 1}.)

Question 5

As discussed in the notes, transitive verbs denote functions of type < e, < e,t >>. Now let us define a function
g that takes as an argument a function of type < e, < e,t >> and returns another function of type < e, < e,t >>
and is defined as follows:
(3) g = [λ f<e,<e,t>>. λ xe .λ ye . f (y)(x)]

5
What is the type of g?
Suppose i(regarde) is defined as in ?? in the handout. What is, then, the function g(i(regarde))?
In general, what does g do to its argument?

Question 6

One of the lexical entries below is a good candidate for being the denotation of the French reflexive pronoun
se which you see in Marie se regarde. Detemine which one. You want se regarde to be a VP and to denote a
function of type < e,t >.
(4) [[se]]M = ?
a. λ P<e,t> .λ xe .P(x)
b. λ P<e,<e,t>> .λ xe .P(x)(x)
c. λ xe .λ P<e,<e,t>> .P(x)(x)
d. λ xe .λ ye .x = y

2 Quantified NPs
Since we are going to introduce nouns, using the category N for nouns, we need to change the label for proper
names. Let us use the labal properN for proper names (and change all of our previous rules accordingly, in the
obvious way).
We extend our syntactic fragments with the following rules:
(5) a. DET → un(e), plusieurs, chaque, aucun(e), la plupart des, plus de deux
b. N → charpentier, linguiste, table, . . .
c. NP → DET N
We call an NP of the form [DET N], a quantifier (as opposed to proper names).
Now our grammar generates sentences such as:
(6) a. Un charpentier sleeps
b. Une linguiste and un charpentier regardent Paul
c. La plupart des linguistes regardent Marie and chaque charpentier, etc.
d. Aucun charpentier écoute Paul
A few cautionary notes:
– My impression is that even if ne is often omitted in spoken French, (6-d) sounds somewhat deviant in the absence
of ne. Maybe aucun by itself belongs to a formal register. We are simply going to ignore this issue, and ignore ne
entirely.
– These rules treat la plupart des and moins de deux as unanalyzed lexical items, which is in fact incorrect. Note
that the correct constituent structure for la plupart des livres is probably something like:
NP

La
plupart
des livres
But we are assuming the following structure:
NP

DET N

la plupart des livres

We need to expand our semantics to deal with such sentences. In these notes, however, the rules I introduce will
not cover the interpretation quantifier in object position. Conjunctive NPs like Une linguiste and un charpentier
and Marie and plusieurs linguistes will be treated in the homework assignment.

6
1 Quantifiers cannot be of type e
VPs denote function of type < e,t >. If we want to apply such a function to an argument, we need the argument
to be of type e. So it might seem that we should say that quantifiers are of type e, in which case their denotation
would be a certain individual in the domain. But that cannot be the case. For instance, if un charpentier must
denote and individual, (7-a) should feel contradictory in the same way as (7-b), contrary to fact:
(7) a. Un charpentier sleeps, and un charpentier ne sleeps pas
b. Jean sleeps, and Jean ne sleeps pas.
Similar arguments can be made for all other quantifiers, all converging to the conclusion that quantifiers are not
referential, hence cannot be of type e.4

1.1 Quantification in first-order logic

Modern logic emerges in part from a desire to create an artificial language able to express quantificational state-
ment. The line that was taken was that one should not try to mirror the syntax of natural languages, which in some
sense was, according to Russell, was in sense ‘hiding’ the logical structure of sentences. For instance, the natural
language statement in (8-a) gets translated as in (8-b)in 1st-order logic:
(8) a. Every man came
b. ∀x(man(x) → came(x)) (‘For all x, if x is a man, then x came’)
• An aside: (8-b) is true (in classical logic) if there exists no man.
The translation is quite far from the syntax of the English sentence, and makes use a variable even though the
English sentence has nothing like a variable. And to make things worse, the translation of (9-a), given in (9-b),
has a different shape from the one in (8-b) (it does not use the symbol →):
(9) a. A man came
b. ∃x(man(x) ∧ came(x)) (‘There exists x such that x is a man and x came’).
It is possible to translate other quantifiers of natural languages into first-order logic, especially if we consider a
first-order logic language that has an equality symbol (‘=’). For instance:
(10) a. At least two women came.
b. ∃x∃y(x 6= y ∧ woman(x) ∧ woman(y) ∧ came(x) ∧ came(y))
(In words: ‘There exists x and y such that x is different from y and x is a woman and y is a woman
and x came and y came).
Before modern logic, Aristotelian logic was essentially a formal system inspired by natural languages whose goal
was to classify all possible syllogisms as valid or invalid. Here is an example of a valid syllogism:

EVERY A B
SOME A C
SOME B C

This reads: from the two premises ‘Every A is a B’ and ‘Some A is a C’, one concludes ‘Some B is a C’.
4 That
being said, indefinites in natural languages behave in some respects like referential expressions. For instance, one can ‘refer’ back
to an indefinite in a sentence in a subsequent sentence as in:

(i) A man came in. He started speaking.

The analysis of such cases and others have motivated a type of semantics called dynamic semantics. The idea is that sentences do not just
express propositions (which you can view as functions from states of affairs to truth-values), but have a richer content: they also introduce
’discourse referents’. So for instance in ’A man came in’, a proposition is expressed (the proposition that is true if and only if a man came in),
a discourse referent corresponding to ’a man’ is introduced. In the subsequent sentence, the pronoun ’he’ picks up this discourse referent. I
might talk about this later this semester, but this will depend on how much we will have covered before. Note that on a ’classical analysis’, the
first sentence in (i) is equivalent to (ii):

(ii) It is not the case that no man came.

Yet continuing with ‘. . . He started speaking’ is quite deviant in such a case, suggesting that (ii) and the first sentence of (i) have in some sense
different meanings, despite expressing the same proposition.

7
 Aristotle’s system is limited in various ways. For instance it does not consider cases which involve relations
(i.e. things like transitive verbs), i.e. sentences like ‘Every student met some professor’. It is basically a finite sys-
tem (there is only a finite number of syllogistic schemes), very far from the expressive power of natural language
and what is needed to formalize mathematics and reasoning in general. However, 1st order-logic has expressive
limitations to. Certain quantified sentences cannot be translated into first-order logic. This is the case, for instance,
when the quantifier most is involved. There is no first-order logic translation for the following sentence:
(11) Most students came.
The formal semantics of natural languages, which to a large extend builds on formal logic, has shown that it is
in fact possible to treat significant fragments of natural languages as formal systems where semantic composition
is essentially driven by the syntax. The seminal work was done by the philosopher-logician Richard Montague.
What we cover in this class for the most part directly springs from Montague’s work. One key paper is entitled
‘The treatment of quantification in ordinary English’
(Available on-line at http://semantics.uchicago.edu/kennedy/classes/s08/semantics2/montague73.
pdf]) .

2 Determiners as expressing relations between sets

2.1 The idea
Let us assume that nouns and VPs denote sets (in our official system, they denote characteristic functions there of).
Let us further schematize sentences of the form [DET N] VP as DET A B, where A and B are viewed as representing
sets (i.e. not really linguistic expressions, but something like their denotation – we are basically ignoring the
distinction between object language and metalanguage in this informal presentation). Then the meaning of various
determiners can be characterized as follows:
(12) a. [Chaque A B] means: A ⊆ B
b. [Un A B] means: A ∩ B 6= 0/
c. [Aucun A B] means: A ∩ B = 0/
d. [Plusieurs A B] means: |A ∩ B| ≥ 2.5
e. [La plupart des A B] means: |A|A|
∩ B|
≥ 0.5
f. etc.
So chaque denotes the inclusion relation, un the relation that holds between two sets if their cardinality is not
empty, etc.

2.2 A constraint on the denotation of determiners: conservativity

There are many conceivable relations between sets, and not all of them are expressed quantifiers. Formal se-
manticists have found apparently universal constraints on the meaning of determiners. A very well-known one is
conservativity
(13) Definition
A determiner DET is conservative if for any two sets A, B,[DET A B] is equivalent to [DET A A ∩ B].
(14) Conservativity constraint
Natural language determiners are always conservative.
Linguistically, the conservativity constraints corresponds to the following equivalences:
(15) a. Chaque table est rouge ⇔ Chaque table est une table rouge
b. Une linguiste est malade ⇔ Une linguiste est une linguiste malade.6
c. Aucun philosophe n’est linguiste ⇔ Aucun philosophe n’est la fois linguiste and philosophe
d. Plusieurs cantatrices dorment ⇔ Plusieurs cantatrices sont des cantatrices qui dorment
e. La plupart des invités sont russes ⇔ La pluprt des invités sont des invités and sont russes.
5 If
X is a set, |X| is the cardinality of X.
6 It
might seem that the equivalent does not hold due to the possibility to interpret singular indefinites as expressing generic statements.
There might be a tendency to interpret the second sentence as meaning something like ‘Linguists are usually/generally/typically sick’. This
is an entirely disctinct use of such sentences. If there is a stronger bias towars this interpretation in the second sentence than in the first, the
equivalence might break down first.

8
Here are conceivable determiners which violate the conservativity constraint and are not attested in natural lan-
guages:7
(16) a. [BLICK A B]⇔ B ⊆ A
b. [BLUCK A B] ⇔ A ⊆ B
c. [BLOCK A B] ⇔ A ( B
Equivalently: [BLICK A B] ⇔ A ⊆ B ∧ B * A
• According to this, a sentence such as BLICK students came would mean the same as All the people who
came are students. Now, one can actually express this thought in English as follows:
(17) Only linguists came
So it might seem that, after all, BLICK is just only, and only would be a counterexample to conservativity. There
are many reasons to think, however, that only is not a deteminer. It does not have the syntax of a determiner in
English, as shown by:
(18) a. Only Peter came
b. Only the linguists came
c. John is only 5 years-old
d. John read only some of the books he had to read.
In all these cases, there is no way to replace only with a determiner and obtain an acceptable sentence.
• BLUCK linguists came would mean something like All the non-linguists came – which in itself does not
tell us anything about whether linguists came.
• Interestingly, BLOCK linguists came would mean something quite straightforward, namely that all the
linguists came, but that there are also non-linguists who came (since it would assert that the set of linguists
is included in the set of the people who came, but that the set of people who came is not included in the set
of linguists).
What conservativity ensures is that in order to check whether a quantified statement of the form DET A B is true,
one never needs to look outside of the set A. The truth value of the sentence only depends on which members of
A belong to B.

3 Determiners as denoting << e,t >, << e,t >,t >> functions
In our ‘official’ system, nouns and VPs do not denote set but characteristic functions thereof, and Determiners,
which we viewed as expressing relations between sets, combine first with the noun, giving rise to an NP that itself
combines with the VP. In the case of transitive VPs, which we originally viewed as relations between individu-
als, we use the technique of currying to turn them into one-place functions. We can do exactly the same with
Determiners. Consider again:
Consider again:
(19) [Chaque linguiste] [est venu]
We want to use FA (functional application) as our only (or at least main) interpretation rule, but we also know that
we cannot treat Chaque linguiste as being of type e. The only reasonable solution is to turn things around: we
will say that chaque linguiste denotes a function which takes as its argument the denotation of the VP, and returns
a truth-value. That is Chaque linguiste must be of type << e,t >,t >. Given this, the word chaque must denote
a function which takes the denotation of a noun and return something of type << e,t >,t >. Since nouns are of
type < e,t >, chaque (and other determiners) must be of type << e,t >, << e,t >,t >>. This is the type of the
curried version of a relation between functions of type < e,t > – in the same way as the type of transitive verbs,
< e < e,t >> is the type of the curried version of a binary relation between individuals.
Given the type, we now know that the denotation for chaque must start with λ P<e,t> .λ Q<e,t> . . . .
Here is how we now specify the denotation of chaque:
(20) [[chaque]]M = λ P<e,t> .λ Q<e,t> .{x : P(x) = 1} ⊆ {x : Q(x) = 1}
Now, this is not coherent with our previous conventions for the metalanguage. Given that the output once we feed
the function its two arguments P and Q should be a truth-value, we should have on the right, after the lambda-
7 If X is a set, then X denotes its complement, i.e. the set of objects in our universe D which are not members of X

9
prefix, something that denotes a truth-value (this was the case when we had things like snores(x), since snores is
an < e,t >-function. But here, for chaque étudiant sleeps, we will end up with a statement such as:
(21) {x : student(x) = 1} ⊆ {x : sleeps(x) = 1}
This statement is a certain claim about the model M (remember that student abbreviates i(student), and that the
function i is provided by the model M). But so far, what we had on the right of a lambda-term was an expression,
which, once given all its arguments, denote an object of the domain (i.e. an individual of the domain D, a truth-
value, of a function defined in terms of these two types of objects, to which a type can be assigned). Here, we
would like to get a truth-value, but we just have a sentence of our metalanguage that talks about the model. But
what we really mean is that, when applied successively to two < e,t >-functions sleeps and sleeps, the function
returns 1 if and only if the statement in (21) is true.
Just like in Heim & Kratzer’s textbook, we need to adopt the following convention for our metalanguage:
(22) A lambda-term of the form λ ατ .φ denotes either (whichever makes sense):
a. The function which maps any object of type τ denoted by o to the result of computing the expression
φ after having replaced all free occurrences of α in φ with o.
or
b. The function which maps any object of type τ denoted by o to 1 if the result of replacing all free
occurrences of α in φ with o gives rise to a true statement, 0 otherwise.
This means that the two following lambda-terms now represent exactly the same function:
(23) a. λ xe .snores(x)
b. λ xe .snores(x) = 1
Suppose we work with (23-a), and let us compute the result of applying (23-a) to an argument j:
(24) [λ xe .snores(x)](d) = snores(d)
1 if snores(d) = 1, 0 if snores(d) = 0
Working from (23-b), we get (via reduction)
(25) [λ xe .snores(x) = 1](d) = [snores(d) = 1]
So we get a statement about the model that is true or false. This is understood to represent 1 if the statement is
true, 0 otherwise.
Let us then compute the truth-value of Chaque linguiste sleeps in model M (ignoring trivial steps having to do
with non-branching nodes):
 M
S
M  M 


 
 NP VP
NP VP  
       
= [[chaque]]M ([[linguiste]]M )([[sleeps]]M )
    
(26)  =  N   V  
 

    DET 
    
 DET

N V   
  Chaque linguiste sleeps
Chaque linguiste sleeps
=[λ P<e,t> .λ Q<e,t> .{x : P(x) = 1} ⊆ {x : Q(x) = 1}](linguist)(sleeps)
= [λ Q<e,t> .{x : linguist(x) = 1} ⊆ {x : Q(x) = 1}](sleeps)
= {x : linguist = 1} ⊆ {x : sleeps(x) = 1}
This is to be interpreted as denoting 1 is the statement is true, 0 otherwise.

Now, the denotation for chaque in (20) can be expressed in 1st-order logic format instead of set-theoretic no-
tations, as in (27):

(27) [[chaque]]M = λ P<e,t> .λ Q<e,t> .∀x(P(x) = 1 → Q(x) = 1)

This is consistent with Heim & Kratzer’s conventions for the metalanguage, but most people in formal semantics
would in fact write this:
(28) [[chaque]]M = λ P<e,t> .λ Q<e,t> .∀x(P(x) → Q(x))

10
We can ourselves do this, by being precise about what → and ∀ mean in our metalanguage. We want the whole
formula ‘∀x(P(x) → Q(x))’ to represent a truth-value. P(x) an Q(x) themselves are either 0 or 1 (depending on
the value of x), so → has to be a function from pairs of truth-values to truth values:

0→0=1
0→1=1
1→1=1
1 → 0 = 0.

Finally, ∀xφ (x) denotes min({φ (a), φ (b), . . .}), where a, b, c, . . . are all the individuals of the domain D. ∀x(P(x) →
Q(x)) is 1 just in case for every individual d in the domain, P(d) → Q(d) is 0, namely if for every d, either P(d) = 0
or Q(d) = 1.

Let us apply this again to Chaque linguiste sleeps:

 M
S
M  M 


 
 NP VP
NP VP  
       
M M M
    
(29) N   V    = [[chaque]] ([[linguiste]] )([[sleeps]] )
  = 
 DET 
      
 DET

N V  

 
  Chaque linguiste sleeps
Chaque linguiste sleeps
=[λ P<e,t> .λ Q<e,t> .∀x(P(x) → Q(x))](linguist)(sleeps) =
[λ Q<e,t> .∀x(linguist(x) → Q(x))](sleeps) = ∀x(linguist(x) → sleeps(x))

Denotations for other determiners

(30) Using set-theoretic notation
a. [[un]]M = λ P<e,t> .λ Q<e,t> .{x : P(x) = 1} ∩ {x : Q(x) = 1} 6= 0/
b. [[aucun]]M = λ P<e,t> .λ Q<e,t> .{x : P(x) = 1} ∩ {x : Q(x) = 1} = 0/
c. [[plusieurs]]M = λ P<e,t> .λ Q<e,t> .|{x : P(x) = 1} ∩ {x : Q(x) = 1}| ≥ 2
d. [[la plupart des]]M = λ P<e,t> .λ Q<e,t> . |{x : P(x)|{x= :1}P(x)
∩ {x : Q(x) = 1}|
= 1}| ≥ 0.5
(31) Using first-order logic notation (impossible for ‘la plupart’)
a. [[un]]M = λ P<e,t> .λ Q<e,t> .∃x(P(x) ∧ Q(x)))
b. [[aucun]]M = λ P<e,t> .λ Q<e,t> .¬∃x(P(x) ∧ Q(x))
c. [[plusieurs]]M = λ P<e,t> .λ Q<e,t> .∃x∃y(x 6= y ∧ P(x) ∧ Q(x) ∧ P(y) = ∧Q(y))

A more complex case

For the next example, we need to remember our special semantic rule for the conjunction of two VP (a case where
we haven’t used functional application):
 M
VP
(32)   = λ xe . [[VP1 ]]M (x) ∧ [[VP2 ]]M (x)
VP1 and VP2
(33) Chaque linguiste sleeps and snores
We will again skip some trivial steps.

11
  M 
VP
M   
NP

  
  
    VP and VP  
 
=  DET N  
   
 
  

 V V   
  
chaque linguiste   
sleeps snores
= [[chaque]]M ([[linguiste]]M )(λ xe . [[sleeps]]M (x) ∧ [[snores]]M (x))
= [λ P<e,t> .λ Q<e,t> .∀x(P(x) → Q(x))](linguist)(λ ye .sleeps(y) ∧ snores(y))
= [λ Q<e,t> .∀x(linguist(x) → Q(x))](λ ye .sleeps(y) ∧ snores(y))
Eliminating Q and replacing it by λ ye .sleeps(y) ∧ snores(y):
= ∀x(linguist(x) → [λ ye .sleeps(y) ∧ snores(y)](x))
Reducing the subformula [λ ye .sleeps(y) ∧ snores(y)](x)
= ∀x(linguist(x) → (sleeps(x) ∧ snores(x)))
= ∀x(linguist(x) → (sleeps(x) ∧ snores(x)))

A digression
In an approach to semantics not based on direct interpretation but translation into a formalized language which
itself gets interpreted, things work differently. In such a ‘Semantics via translation’ approach, natural language ex-
pressions are mapped to a formal language that typically has lambda terms plus first-order logic and set-theoretical
notation. This formal language is the one that gets interpreted with respect to a model. In such a system, you end
up writing exactly the same thing as above. 8
(34) hhchaqueii = λ P<e,t> .λ Q<e,t> .∀x(P(x) → Q(x))
When chaque combines with a VP, the resulting translation is just the concatenation of the translation of chaque
and that of the VP, and then reduction can be performed to get a well-formed first-order logic formula:
S

** ++
NP VP
(35) = · · · = [λ P<e,t> .λ Q<e,t> .∀x(P(x) → Q(x))](linguist)(sleeps)
DET N V

Chaque linguiste sleeps

= (via reduction) ∀x(linguist(x) → sleeps(x))
But the interpretation is different: in our ‘official’ approach what you have on the right is a truth-value, either 0 and
1. In the ‘translation approach’, what is on the right is just a sentence of some artificial language. In our system,
[[Marie est linguiste]]M is either the number 1 or 0. In the ‘semantics by translation’ system, hhMarie est linguisteii
is a certain formula of the language into which we translate. But we chose conventions for our metalanguage
which allow us to work ‘as if’ we were translating into some other language (lambda calculus + 1st-order logic,
for instance). We end up with things like [[Chaque linguiste est heureux]]M = ∀x(linguist(x) → happy(x)). It looks
like what we have done is translate the sentence into a formula of first-order logic. However, the thing written on
the right does not (in our official system) denote a proposition but just a truth-value - namely the truth-value of
the sentence in the model M - keeping in mind that linguist is just an abbreviation for I(linguist) (for instance),
where i is a component of M.

A second digression: lexical words and logical words

You may have noticed that the denotation of determiners does not refer to the model M, while that of nouns
and verbs do (officially we have [[linguiste]]M =i(linguiste), where i is the interpretation function of M). So
if we move from a model to another model based on the same domain D, the denotation of a quantifier does
not change. Furthemore, if we characterize them in terms of set-theoretic operations, their meaning is in a certain
sense constant across models even when they don’t share the same domain of individuals. In this sense quantifiers,
just like negation, are logical words. This is one reason not to write anything like i(chaque)= · · · , which would
8 Not using our denotation brackets anymore, but rather hh. . . ii so as to not be confused about the two types of systems

12
suggest that the denotation of chaque depends on the choice of i. Instead, we directly define the denotation of
chaque using the denotation brackets.

Terminology: Generalized Quantifiers

Quantified NPs such as chaque linguiste, when analyzed as denoting functions of type << e,t >,t >, are called
Generalized Quantifiers (GQ), while the word chaque is called a determiner. Yet quite often the label quantifier
is used for Determiners too.
In our system a GQ denotes a characteristic function of a set of sets of individuals.

13