CAS LX 502
Semantics
3b. A formalism for meaning
(cont’d again): F2
3.2, 3.6
Full summary of F1
S  N VP
S  Neg S
S  S ConjP
[S N VP]M = true iff [N]M  [VP]M
[S Neg S´]M = true iff [S´]M  [Neg]M
[S S ConjP]M = true iff [S]M  [ConjP]M
ConjP  Conj S
VP  Vt N
VP  Vi
[ConjP Conj S]M = {x : < x, [S]M >  [Conj]M }
[VP Vt N]M = {x : < x, [N]M >  [Vt]M }
[ [X] ]M = [X]M for any X
N  Pavarotti, …
Vi  is boring, …
Vt  likes
[X]M = F(X) where X is a terminal node
F(Pavarotti) = PAVAROTTI
F(is boring) = {x: x is boring in M}
F(likes) = { <x,y> : x likes y in M }
Conj  and, or
Neg  it is not…
F(and) = {<true, true>}, F(or) =
{<true, true>, <true,false>, <false,true>}
F(iintct) = {false}
What we have


We have created a little fragment describing a
(very small) subset of English, generating structural
descriptions of syntactically valid sentences and
providing the means to determine the truth
conditions of these sentences.
We did this by formulating a set of syntactic rewrite
rules, each accompanied by a semantic rule of
interpretation, such that every syntactic step can
be interpreted compositionally.
One step more general

Looking over the rules that we have, there are basically just
two kinds:






[S N VP]M = true iff [N]M  [VP]M
[S S ConjP]M = true iff [S]M  [ConjP]M
[S Neg S]M = true iff [S]M  [Neg]M
[VP Vt N]M = {x: <x,[N]M>  [Vt]M }
[ConjP Conj S]M = {x: <x,[S]M>  [Conj]M }
More generally:

[A B]M = true iff [A]M  [B]M


[A B]M = {x: <x,[A]M>}  [B]M



(where [B]M is a set of [A]M-type things)
(where [B]M is a set of pairs, the second member being an [A]M-type thing)
[ [A] ]M = [A]M
This will cover our other rules… and make it easier to extend
our syntax as well.
One step further…?

If we have these rules:

[A B]M = true iff [A]M  [B]M


[A B]M = {x: <x,[A]M>  [B]M }





(where [B]M is a set of [A]M-type things)
(where [B]M is a set of pairs, the second member being an [A]M-type thing)
[ [A] ]M = [A]M
It still feels as if the first two rules are kind of the same, perhaps the first
is a “special case” of the second. But it’s not obvious exactly how to
formulate one rule that will apply to both situations.
Suppose that the second rule is the more general, and we want to
subsume the first rule into the second. What would need to happen?
The first rule applies to properties: For example VP and N under S,
where [A]M is the denotation of N, and [B]M is the denotation of VP.
An option…

If we have these rules:

[A B]M = true iff [A]M  [B]M


[A B]M = {x: <x,[A]M>  [B]M }




[ [A] ]M = [A]M
Sure, ok. Suppose F(is boring) is something like this (in some particular model):
F(is boring) = {<true, Bond>, <false, Loren>, <true, Pavarotti>}
Or in general,


(where [B]M is a set of pairs, the second member being an [A]M-type thing)
So what would we need to do for properties like VP applied to N to fit the
description of the second rule? We would need to think of properties also as
being sets of pairs.


(where [B]M is a set of [A]M-type things)
F(is boring) = {<x,y>: y is an individual in U, and x is true if y is boring in M, false otherwise}
Then, if we combine is boring with Bond, we can use the second rule, and, in
that same particular model, get {true}.
An option…

If we have these rules:

[A B]M = true iff [A]M  [B]M


[A B]M = {x: <x,[A]M>  [B]M }





(where [B]M is a set of [A]M-type things)
(where [B]M is a set of pairs, the second member being an [A]M-type thing)
[ [A] ]M = [A]M
If we end up with {true} for Bond is boring, we still don’t exactly have a truth
value. But we can simply stipulate that if the semantic value of a sentence is
{true}, the sentence is true, and if it is {false} the sentence is false.
We would also need to redefine transitive verbs, such as like. They should be
pairs so that when the second rule applies to the pair, it results in a set of pairs
(of the same sort is boring was).
So, if we used to think of likes as {<Bond, Loren>, <Loren, Pavarotti>}, we would
now need to think of it as:

F(likes) = {<<true,Bond>,Loren>, <<false,Bond>,Pavarotti>, …}
An option…

Trying to just get by with these rules:

[A B]M = {x: <x,[A]M>  [B]M }



[likes Loren]M = {x: <x,[Loren]M>  [likes]M} = {x: <x,F(Loren)>  F(likes)}
= {x: <x,Loren>  {<<true,Bond>,Loren>, <<false,Bond>,Pavarotti>, …}}
= {<true, Bond>, <false, Pavarotti>, <false, Loren>}
And then combine likes Loren with Bond, which will pick out all the things that
are paired with Bond:


F(likes) = {<<true,Bond>,Loren>, <<false,Bond>,Pavarotti>, …}
The way this works is we combine likes and Loren, say, using the rule above,
which will pick out a set of all the things that are paired with Loren:


[ [A] ]M = [A]M
So, if we used to think of likes as {<Bond, Loren>, <Loren, Pavarotti>}, we would
now need to think of it as:


(where [B]M is a set of pairs, the second member being an [A]M-type thing)
[Bond likes-Loren]M = {x: <x,[Bond]M>  [likes-Loren]M}
= {x: <x,F(Bond)>  {<true, Bond>, <false, Pavarotti>, <false, Loren>}}
= {x: <x,Bond>  {<true, Bond>, <false, Pavarotti>, <false, Loren>}}
= {true}
And by our stipulation, this means the sentence is true.
Win some and lose some?




That’s great! Two rules for the semantics: one
for combinations, and one trivial one for
single-branches.
Except it’s now much less intuitive and it’s
harder to write. It seems to work, but is it
progress?
Answer: Yes, but we need to make it more
intuitive and easier to write.
So, let’s think about our one (substantive)
semantic rule. What does it actually do?
Collecting things paired with…

Here is our rule.



[A B]M = {x: <x,[A]M>  [B]M }
In plain English, combining a set of pairs with
an element x gives us the set of things that
are paired with x.
But suppose we instead think of [B]M above
as a little box that accepts an element x
and returns a set of things. The set of pairs
we attributed to it simply describe the box’s
behavior.

E.g., give it Bond, it’ll give you {true}.
The little box


Here’s a picture of the little box. Let’s call it f.
We can think of it as a mapping from an input to an
output.
input


f
output
Oh, right. Yes. It’s a function.
We can describe the behavior of the function by
listing explicitly (as pairs of outputs and inputs) what
it does, or we could state what it does to an input to
form the output (e.g., f(n) = 2+n).
Functions

We have several way to write a function. Suppose we want to
write the not function that reverses a truth value. So, a truth
value is provided as an input and a truth value is returned as
an output.


We can also write the mapping explicitly, using ordered pairs
of the form <output, input>:


fnot is a function that, for any x{true,false}, returns x.
fnot = {<true, false>, <false, true>}
Or, we can write in the form input[output]:

fnot = x[x].

Side note: If writing the mapping explicitly in most contexts, the convention
would be to write the pairs as <input,output>. Here I used <output,input> for
compatibility with the semantic rule we developed the idea from, but the
information content is the same, whichever way you write it (so long as you
define which member of the pair is the input and which is the output).
How does this help?

If we think about these in terms of functions,
we can forget about the pairs and just
concentrate on describing the functions.



[is boring]M = the function f such that
f(x)=true iff x is boring in M.
This function takes individuals as input. We’ll
say these are type <e>. It gives truth values
as an output, which we’ll say are type <t>.
We can talk about the type of function [is
boring] is as <e,t>: takes an <e>, returns a
<t>.
Enter the 

The standard way to describe functions like this in
semantics is using lambda notation.


The structure of a function written in lambda notation is:
 argument [ return value ]
So, for [is boring]M, we can write this:


 x [ x is boring in M ]
This is the function such that, given an individual x, returns true if
x is boring in M and false otherwise.

We are now changing F somewhat. F(is boring) will no longer the set
of boring individuals in M, but rather the function that is true of all and
only the boring individuals in M. (The “characteristic function” of the
set)
 argument [ return value ]



 x [ x is boring in M ]
The idea here is that x is boring in M is
either true (if x is boring in M) or false (if
x is not boring in M), and so whatever
truth value x is boring in M has will be
what this function returns.
This is a function of type <e,t>.
 argument [ return value ]

Change-machine($n-bill) = 4  n quarters.
Change-machine =  $n-bill [ 4  n quarters ]

Square =  n [ n  n ]


Not very complicated, just a short way to
write “that function f such that, given
argument, returns return value.”
 argument [ return value
](value)

Square =  n [ n  n ]



Square(3) = 3  3 = 9
Square(4) = 4  4 = 16.
To evaluate a function given a value, we take the
value and substitute it in for the argument within the
return value. If we give it a 3, and the argument is n,
then we replace all of the ns with 3s and evaluate
the return value.

Known as “lambda conversion.”
 argument [ return value
](value)


One last piece of terminology: Instances of
argument within return value are said to be
variables that bound by the lambda operator.
Triple =  n [ 3  n ]
Lambda operator
Bound variable
Back to likes…

In F1, the value of F(likes) was a set of pairs
(the likers paired with the likees for a given
model).


In the intermediate version we developed above, the
value of F(likes) was more complex: A set of pairs, one
member of each pair being a pair itself.
F(likes) = {<<true,Bond>,Loren>, …}


This was because we wanted the set of things paired with the
object to be a set of pairs itself—a property (of being a Bondliker), just like is boring.
But pairs define the behavior of a function. In terms of
functions, we want F(likes) to be a function that
returns a function.
Functions returning functions

With the help of , we can easily describe the
function we want likes to return.


F(likes) = y[x[x likes y in M]]
So give likes Bond:

y[x[x likes y in M]](Bond)


x[x likes Bond in M]


The return value is the function x[x likes y in M]. Lambda
conversion: Change all ys in the return value to Bond:
And this is the property of being a Bond-liker. Give it an individual,
and it will return true if that individual likes Bond and false
otherwise.
x[x likes Bond in M](Loren)
= Loren likes Bond in M

After lambda conversion, this is either true or it’s false.
What this buys us




Defining things in terms of functions allows us to reduce our
semantic rules to the following (the official rules of F2):
Functional application:
[a b]M = [a]M([b]M) or [b]M([a]M),
whichever is defined.
Pass up:
[b a]M = [a]M
We will also redefine the verbs as functions instead of sets (of
pairs), and the overall system will wind up simpler (and I think
more comprehensible) than it was with sets.
S  N VP
[S N VP]M = true iff [N]M  [VP]M,
otherwise false
S  S Conj S
S  Neg S
VP  Vt N
VP  Vi
N  Pavarotti,
…
Vi  is boring,
…
Vt  likes
Conj  and, …
[S S1 Conj S2]M = [Conj]M ( < [S1]M, [S2]M > )
[S Neg S´]M = [Neg]M ( [S´]M ).
[VP Vt N]M = {x : < x, [N]M >  [Vt]M }
[Pavarotti]M = F(Pavarotti)
[is boring]M = {x: x is boring in M}
[likes]M = { <x,y> : x likes y in M }
[and]M = {<<true,true>,true>,
<true,false>,false>, …}
M
Generalizing our semantics

M=<U,F>

[Bond]M = F(Bond) = Bond


[is
= F(is hungry) =
the function f such that,
given an individual x, it
returns true if x is hungry in M,
false otherwise.

N
VP
Type: <e>
hungry]M

S
x[x is hungry in M]
Type: <e,t>
Bond
Bond
Vi
is hungry
The function f such that,
given an individual x,
it returns true if x is hungry in M,
false otherwise
Generalizing our semantics




Pass-Up:
[b a]M = [a]M
What this says is that if a
node b contains nothing else
but a node a, then the
semantic value of b is going
to be exactly the same as
the semantic value of a.
So [N]M = [Bond]M = Bond.
[VP]M = [Vi]M = [is hungry]M.
S
N
Bond
Bond
VP
Vi
is hungry
The function f such that,
given an individual x,
it returns true if x is hungry in M,
false otherwise
Generalizing our
semantics





Functional application:
[g a b ]M = [b]M ( [a]M )
or
[a]M ( [b]M )
whichever is defined
What this says if a node b contains two
things, one being a function that takes
the other as an argument, the result
will be whatever the function returns
given that argument.
[N]M is type <e>
[VP]M is type <e,t>
So [S]M is type <t>.
The function f such that,
given an individual x,
it returns true if x is hungry in M,
false otherwise
Bond
S
N
Bond
Bond
VP
Vi
is hungry
The function f such that,
given an individual x,
it returns true if x is hungry in M,
false otherwise
Generalizing our
semantics




Functional application:
[g a b ]M = [b]M ( [a]M )
or
[a]M ( [b]M )
whichever is defined
The function f such that,
given an individual x,
it returns true if x is hungry in M,
false otherwise
Bond
S
N
VP
[S]M = [S N VP]M = [VP]M ( [N]M )
[VP]M is the function such that
given an individual x, it returns true
if x is hungry in M, false otherwise.
Bond
Bond
Vi
is hungry
[N]M is the individual Bond.
The function f such that,
given an individual x,
it returns true if x is hungry in M,
false otherwise
Generalizing our
semantics



Functional application:
[g a b ]M = [b]M ( [a]M )
or
[a]M ( [b]M )
whichever is defined
[S]M = [S N VP]M = [VP]M([N]M)
So, [S]M is true if Bond is
hungry in M, false otherwise.
The function f such that,
given an individual x,
it returns true if x is hungry in M,
false otherwise
Bond
S
N
Bond
Bond
VP
Vi
is hungry
The function f such that,
given an individual x,
it returns true if x is hungry in M,
false otherwise
Like, totally.





Transitive verbs, such as like, are
ultimately relations between
individuals.
Yet, our syntax produces structures like
this, where VP has only likes and Loren
in it.
We know that [S]M needs to be a truth
value, it needs to be of type <t>.
We know that [N]M is an individual
(Bond), type <e>.
Given the way Functional Application
works, [VP]M needs to be a function of
type <e,t>.
<t>
<e,t>
<e>
S
VP
N
Bond
Vt
N
likes
Loren
Like, totally.



[VP]M
What we want
to be is a function
that is true of all Loren-likers, such that
the whole sentence will be true if Bond is
a Loren-liker.
[VP]M?
So, what is
Well, that too has two
parts. We know that it needs to be of
type <e,t>. We know that one
component (N) is an individual of type
<e>. So we need [Vt] to be something
that takes an individual, type <e>, and
returns a predicate, type <e,t>.
That is, [Vt] must be type <e,<e,t>>.
<t>
<e,t>
<e>
S
VP
N
Bond
<e>
Vt
N
likes
Loren
Like, totally.




If [Vt] is of type <e,<e,t>>, it is a function
that takes an individual and returns a
function, specifically a function from
individuals to truth values.
The particular function we need it to
return is the one that is true of Lorenlikers.
<t>
<e,t>
<e>
S
VP
N
Bond
<e>
Vt
N
likes
Loren
So, how do we write that?
Well,  argument [ return value ]
<e,<e,t>>
Like, totally.

What we’re aiming for is
something that will work out to:

S
 x [ x is a Loren-liker in M ]
N


But we want to derive x is a Lorenliker in M from like and Loren.
Vt
M
M
(That is, from [Vt] and [N] ). We Bond
know what [N]M is, it’s Loren. So,
what’s [Vt]M ?
likes
[like]M =  y [  x [ x likes y in M ] ]
VP
N
Loren
Like, totally.



[like]M =  y [  x [ x likes y in M ] ]
That is, [like]M is the function that,
given an individual y, returns the
function that, given an individual
x, is true if x likes y in M.
[VP]M
Bond
S
Loren
VP
N
Bond
Vt
So, what is
? Well, it
contains Vt and N, and [Vt]M is a
likes
function of type <e,<e,t>> that
takes an argument of type <e>.
[N]M is of type <e>. So, [VP]M =
[Vt]M ( [N]M ).
 y [  x [ x likes y in M ] ]
N
Loren
Like, totally.



[like]M =  y [  x [ x likes y in M ] ]
S
[VP]M = [Vt]M ( [N]M )
[VP]M =

Loren
VP
N
Loren  y [  x [ x likes y in M ] ]

Bond
Bond
…and lambda conversion gives us…
=  x [ x likes Loren in M ]
 y [  x [ x likes y in M ] ]
Vt
N
likes
Loren
 x [ x likes Loren in M ]
Like, totally.

[VP]M =  x [ x likes Loren in M ]
Bond

Then, we evaluate [S]M. It has two
constituents, one a function of
type <e,t>, the other an individual
of type <e>. Apply Functional
Application.
 [S]M
=
[VP]M
(
[N]M
)
S
Loren
VP
N
Bond
= Bond  x [ x likes Loren in M ]
= Bond likes Loren in M
 y [  x [ x likes y in M ] ]
Vt
N
likes
Loren
Generalized semantics


We now have a relatively simple semantic theory. Each
node in the (syntactic) structure has a semantic value. If
the node has a sister, one of them is a function and one
of them is an argument, and the semantic value of both
together is whatever the function yields, given the
argument (Functional Application). If a node has no
sisters, its parent node just has the same semantic value
(Pass-up).
The semantic values of the lexical items reflects this
structure. So the semantic value of names will be of
type <e>, that of intransitive verbs will be of type <e,t>,
that of transitive verbs will be of type <e,<e,t>>.
and


[and]M =  y [  x [ x  y ] ]
[ConjP]M = [Conj]M ( [S2]M )
=  y [  x [ x  y ] ] ( [S2

S
]M
)
ConjP
S1
=  x [ x  [S2]M ]
Conj
[S]M = [ConjP]M ( [S1]M )
and
=  x [ x  [S2]M ] ( [S1]M )
= [S1]M  [S2]M
S2
S  N VP
S  Neg S
S  S ConjP
ConjP  Conj S
VP  Vt N
VP  Vi
N  Pavarotti, …
Vi  is boring, …
Pass-Up:
[b a]M = [a]M
F2
Functional application:
[g a b ]M =
[b]M ( [a]M )
or
[a]M ( [b]M )
whichever is defined
[a]M = F(a) where a is a terminal node
[is boring]M =  x [ x is boring in M ]
Vt  likes
[likes]M =  y [  x [ x likes y in M] ]
Conj  and, …
[and]M =  y [  x [ x  y ] ]
Neg  it is not the [iintct]M =  x [ x ]
case that









