CAS LX a. A notational holiday

Sets A set is a collection of entities of any kind. They can be finite: {√2, John Saeed, 1984}. They can be infinite: the set of integers greater than 5. We can specify a finite set by listing its members. We can also specify a set by its description: {x : x is a book written by Chomsky} This set contains any x such that x is a book written by Chomsky—any other x is not in the set. A set is defined by its members. {n: n is an even number} = {n: n+1 is an odd number} Order makes no difference, repetition is meaningless: {1, 5, 7} = {5, 7, 1} = {7, 1, 5} = {7, 1, 1, 5, 7}

Set notations We can name a set if we wish: A={1, 3, 8}. If A={1, 3, 8} and B = A, then B = {1, 3, 8}. a  A means a is a member of the set A. a  A means a is not a member of A. 1  {1, 3, 8}; 4  {1, 3, 8}. Ø is the “empty set” a set that has no members. It could also be written like this: {}.  x [x  Ø]

Set notations A  B means that everything in A is also in B, although there may be more stuff in B (“A is a subset of B”).  x [x  A  x  B] A  B means that not only is everything in A in B, but there is something else in B that isn’t in A (“A is a proper subset of B”).  x [x  A  x  B]   x[x  B  x  A] A = B means that everything in A is in B and everything in B is in A.  x [(x  A  x  B)  (x  B  x  A)]

Set notations A  B is the set of elements that are both in A and B (“the intersection of A and B”). A  B = {x: x  A  x  B} A  B is the set of elements that are either in A or in B, or in both (“the union of A and B”). A  B = {x: x  A  x  B} If two sets have no overlap, they are said to be disjoint. A and B are disjoint iff A  B = Ø.

Ordered pairs Ordered pairs are like a two-membered set in which order matters: ≠ ; ≠ {1, 3} = {3, 1}; {1, 1} = {1} An ordered n-tuple is sometimes called a vector:

Labeled brackets The labeled bracket notation is another way to write hierarchical information. [ A B C] is a group, containing B and C, that is labeled collectively as A. A BC

Labeled brackets So, the tree on the right provides the same information as: [ S [ NP [ Np Bond ] ] [ VP [ Vt likes] [ NP [ Np Loren] ] ] ] S NPVP Vt likes NPNP Bond NP NPNP Loren

Functions Back to functions for a bit. A function is a mapping from an input to an output. Generally, the output that results depends on the input received (e.g., f(x) = 2  x) (although one could define a constant function that maps any input into the same output; e.g. f(x) = 2). f inputoutput

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. f not is a function that, for any x  {true,false}, returns  x. We can also write the mapping explicitly, using ordered pairs of the form : f not = {, } Or, we can write in the form input[output]: f not = x[  x].

Applying functions to arguments The input that we provide to a function is called its argument. f not (true) = the output f not maps true to. f not (true) = x[  x] (true) = true x[  x] =  true = false.

Functions returning functions A function can return not a single value (like false or Bond), but a function that is ready to apply to a different argument. f and = y [ x [ x  y ] ] This function takes a single argument, returns a function. f and (true) = y [ x [ x  y ] ] (true) = true y [ x [ x  y ] ] = x [ x  true ] The resulting function maps true to true and false to false. f and (false) = y [ x [ x  y ] ] (false) = false y [ x [ x  y ] ] = x [ x  false ] The resulting function maps true to false and false to false.

Formally stating -conversion value vbl [ result ] or vbl [ result ] (value) When we evaluate this we get result, but with all of the instances of variable within result replaced with value. 8 x [ 12 + x  x ] =  8 = = 76

Modified functions Suppose f square = x [ x  x ]. f square (2) = 4, f square (3) = 9, f square (4) = 16, etc. Now, suppose we want a new function, f new, that is just like f square except that if you give it 3, it gives you 5 instead of 9. f new (2) = 4, f new (3) = 5, f new (4) = 16, etc. We can write it like this: f new = f square [3/5]. This means: f new (x) = 5 if x=3, f square (x) otherwise.

Returning to the task… Now, we can get back to the task at hand. We have intuitions about the truth conditions of sentences—we know what it would take for a sentence to be true or false. Limiting ourselves to a small portion of English, and a very restricted set of situations, we try to put together a system to predict those intuitions and try to understand how they come about.

Our little fragment (F 2 ) With our fragment of English, we have a set of syntactic rules that can generate a small number of recognizably English sentences. Sentences have subjects and verb phrases (S  NP VP), verb phrases can either have intransitive verbs (VP  Vi) or transitive verbs with an object (VP  Vt NP). Noun phrases can either be proper names (NP  N P ) or consist of a determiner and a common noun (NP  Det N C ). Sentences can be negated (S  Neg S) or coordinated (S  S ConjP; ConjP  Conj S).

Syntactic base rules S  NP VPVP  Vt NP S  S ConjPVP  Vi ConjP  Conj SNP  Det N C S  Neg SNP  N P Det  the, a, everyN P  Pavarotti, Loren, Bond, Nemo, Dory, Blinky, Semantics, The Last Juror, he n, she n, it n, him n, her n, himself n, herself n, itself n. Conj  and, or Vt  likes, hates Vi  is boring, is hungry Neg  it is not the case thatN C  book, fish, man, woman

Situations and truth Since the truth of Bond likes Loren depends on the situation, we evaluate a sentence like Bond likes Loren against a model of the situation. The model (M) tells us who the individuals are (the “universe” U) and their properties and relations (F). We write that like M=.

The denotation function F The F function (“denotation function”) applies to lexical items (the nodes at the bottom of the tree) and returns a semantic value (the “denotation”). F(Bond) returns the individual from U that we refer to with the proper name Bond. F(is boring) returns a set of the boring individuals from U in the situation modeled by M. F(likes) returns a set of ordered pairs, where x and y are individuals from U, and x likes y in the situation modeled by M.

Semantic rules Our semantic rules are based on the assumption that the meaning of any constituent part of the sentence structure should arise from the meanings of its own parts and how they are combined (meaning is compositional). We have a set of rules to interpret the lexical items (the bottom nodes on the tree), and then two general rules: Pass- up (the meaning of a constituent with only one part is the same as the meaning of that one part) and Functional Application (the meaning of a constituent with two parts is the result of providing one as the argument of the other, where one is always a function).

Semantic types We can classify the kinds of functions each node represents by using a notation that tells us what kind of argument the function takes, and what kind of result it provides: We add two basic types: = individual, = truth value (true or false). These can only be arguments or results, they are not functions. A function like x [ x is boring in M ] is type because it is true or false of individuals.

Lexical interpretation rules To interpret proper names, we use the denotation provided by F. [Pavarotti] M,g = F(Pavarotti) To interpret intransitive verbs or common nouns, we use a function that is true of an individual when the individual is in the denotation provided by F. [is boring] M,g = x [ x  F(is boring) ] [fish] M,g = x [ x  F(fish) ]

Bond is hungry S NP VP Vi is hungry NPNP [Bond] M,g = F(Bond) [is hungry] M,g = x [ x  F(is hungry)] Bond

Bond is hungry Pass-up tells us that the meaning of a node connected by just a single branch to a single daughter node has the same interpretation as the daughter node. S NP VP Vi is hungry NPNP [Bond] M,g = F(Bond) [is hungry] M,g = x [ x  F(is hungry)] Bond

Bond is hungry S has two daughters, one is a function ( ) and one can serve as an argument ( ) for it. So, [S] M,g is the result of applying the function [VP] M,g to the argument [NP] M,g (Functional Application) S NP VP Vi is hungry NPNP [Bond] M,g = F(Bond) [is hungry] M,g = x [ x  F(is hungry)] Bond

Bond is hungry [S] M,g =[VP] M,g ( [NP] M,g ) = x [ x  F(is hungry)] ( F(Bond) ) = F(Bond) x [ x  F(is hungry)] = F(Bond)  F(is hungry) S NP VP Vi is hungry NPNP [Bond] M,g = F(Bond) [is hungry] M,g = x [ x  F(is hungry)] Bond

Lexical interpretation rules To interpret transitive verbs, we use a function that, given the object as an argument, returns a predicate ( ) that can be applied to the subject, and is ultimately true if the ordered pair is in the denotation provided by F. [likes] M,g = y [ x [  F(likes) ] ] >

Bond likes Loren S NPVP Vt likes NPNP Bond NP NPNP Loren [Bond] M,g = F(Bond) [Loren] M,g = F(Loren) y [ x [  F(likes) ] ] > Lexical interpretation rules

Bond likes Loren S NPVP Vt likes NPNP Bond NP NPNP Loren [Bond] M,g = F(Bond) [Loren] M,g = F(Loren) y [ x [  F(likes) ] ] > Pass-up

Bond likes Loren S NPVP Vt likes NPNP Bond NP NPNP Loren [Bond] M,g = F(Bond) [Loren] M,g = F(Loren) y [ x [  F(likes) ] ] > Functional Application: [Vt] M,g is type > (takes an argument), and [NP] M,g is type. So [VP] M,g = [Vt] M,g ([NP] M,g ) = y [ x [  F(likes) ] ] ( F(Loren) ) = F(Loren) y [ x [  F(likes) ]] = x [  F(likes) ] x [  F(likes) ]

Bond likes Loren S NPVP Vt likes NPNP Bond NP NPNP Loren [Bond] M,g = F(Bond) [Loren] M,g = F(Loren) y [ x [  F(likes) ] ] > Functional Application: [VP] M,g is type (takes an argument), and [NP] M,g is type. So [S] M,g = [VP] M,g ([NP] M,g ) = x [  F(likes) ] ( F(Bond) ) = F(Bond) x [  F(likes) ] ] =  F(likes) x [  F(likes) ]  F(likes)

The problem with object quantifiers Proceeding on, the definition of every is: [every] M,g = P [ Q [  x  U [P(x)  Q(x)] ] ] The idea is that every P Q is true whenever being P implies being Q. That is, every fish is boring means for all x (in the universe U), if x is a fish, then x is boring. So, every needs two predicates to be true or false. One is the common noun, the other is the sentence with a variable in place of the quantifier: (every (fish)) (something B likes). S NPVP Vt likes NPNP Bond NP Det every NCNC fish,t>,,t>> >

The problem with object quantifiers The problem with having a quantifier like every fish in object position is that it leaves no way to interpret [VP] M,g. Neither daughter is a function that can take the other as an argument. One needs (but the other is,t>). One needs (but the other is >). This is why QR is needed. QR replaces the NP with t i, interpreted as type, which can be taken by [Vt] M,g as an argument. S NPVP Vt likes NPNP Bond NP Det every NCNC fish,t>,,t>> >

Quantifier Raising S NPVP Vt likes NPNP Bond NP Det every NCNC fish S NPVP Vt likes NPNP Bond NP Det every NCNC fish t1t1 S 1 S

Quantifier Raising [  i ] M,g = g(i):the individual that i points to [S] M,g =  F(likes) [Bond likes him 1 ] S NPVP Vt likes NPNP Bond NP Det every NCNC fish t1t1 S 1 S >

Quantifier Raising The goal is to provide every with two predicates; it has gotten fish. It needs one that means something Bond likes. We can deduce that [S] M,g must be a predicate (type ), and that therefore [1] M,g must be type >. We want [1] M,g to turn Bond likes it 1 into something Bond likes. S NPVP Vt likes NPNP Bond NP Det every NCNC fish t1t1 S 1 S >,,t>>,t>

Lambda abstraction We have something that means Bond likes it 1 (  F(likes) ). We want something that means something Bond likes: x [  F(likes) ] So, what we want to do is add a and a variable (x) to make it a function, and then replace g(1) with x inside the result.

Modified assignment functions How do we change g(1) inside S somewhere to x? One way to do it is to evaluate S with a modified assignment function. What we want is to have this function map 1 to whatever x is, but otherwise act like g. We write that assignment function like g[1/x].

Quantifier Raising [S] M,g =  F(likes) [S] M,g[1/x] =  F(likes) =  F(likes) S NPVP Vt likes NPNP Bond NP Det every NCNC fish t1t1 S 1 S >,,t>>,t>

Quantifier Raising So we define [1] M,g as S [ x [ [S] M,g[1/x] ] ] and we end up with [S] M,g = x [  F(likes) ], as desired. S NPVP Vt likes NPNP Bond NP Det every NCNC fish t1t1 S 1 S >,,t>>,t>

Quantifier Raising [S] M,g = Q [  x  U [x  F(fish)  Q(x)] ] ( x [  F(likes) ] ) =  x  U [x  F(fish)   F(likes) ] S NPVP Vt likes NPNP Bond NP Det every NCNC fish t1t1 S 1 S >,,t>>,t> P [ Q [  x  U [P(x)  Q(x)] ] ] Q [  x  U [x  F(fish)  Q(x)] ] x [  F(likes) ] >

[Pavarotti] M,g = F(Pavarotti) (any N P ) [is boring] M,g = x [ x  F(is boring) ] (any N C or Vi) [likes] M,g = y [ x [  F(likes) ] ] (any Vt) [and] M,g = y [ x [ x  y ] ] (analogous for or) [it is not the case that] M,g = x [  x ] [  i ] M,g = g(i) [i] M,g = S [ x [ [S] M,g[i/x] ] ] [every] M,g = P [ Q [  x  U [P(x)  Q(x)] ] ] [a] M,g = P [ Q [  x  U [P(x)  Q(x)] ] ] Pass-Up [   ] M,g = [  ] M,g Functional application [   ] M,g = [  ] M,g ( [  ] M,g ) or [  ] M,g ( [  ] M,g ) whichever is defined Quantifier Raising [ S X NP Y ]  [ S NP [ S i [ S X t i Y ] ] ]

            