Document Related

Document Description

LIN3021 Formal Semantics Lecture 4. Albert Gatt. In this lecture. Compositionality in Natural Langauge revisited: The role of types The type d lambda calculus. Part 1. Compositionality for Natural Language: the role of types and functions. Montague’s programme.

Document Share

Document Transcript

LIN3021 Formal SemanticsLecture 4Albert GattIn this lectureCompositionality in Natural Langauge revisited: The role of types The typedlambda calculus Part 1Compositionality for Natural Language: the role of types and functionsMontague’s programmeAs we saw last week, Montague attempted to define a programme where: There is a precise set of syntactic rules for languages such as English There is a corresponding set of semantic rules. E.g. We can determine the truth value of a sentence by applying the semantic rules corresponding to the syntactic rules that gave rise to it. Note the parallel to what we were doing for logic. Last week, we did some of this informally. Let’s see how we can make these ideas more precise. Predicates revisitedWe said that simple predicates like sleeps can be viewed like this: If we plug in something of the right kind, saturating the predicate, we get something that returns true or false (i.e. a proposition). Predicates as functionsGiven a model, the predicate can be thought of as a set: E.g. [[sleep]]M,g= {paul, mary} could be a fragment of our model (Technically, the set is the extension of the predicate) It can also be thought of as a function which, given something of the right kind, returns: TRUE if that thing is in the extension of the predicate, FALSE otherwise. It’s useful to think of this as a function: from entities in U (the set of individuals in the model) to truth values. Predicates and typesWhat we use to saturate a predicate must be of the right kind. Our consists in part of a set of individuals (paul, mary). Our language also has: one-place predicates (sleep, eat, book...) two-place predicates (read, love...) ... (other stuff we might need) So how do we specify that something is of the right kind? Predicates and typesRecall one of our interpretation rules from last week: If a node x has two daughters y and z, and [[y]] is an individual and [[z]] is a property, then saturate the meaning of z with the meaning of y and assign the resulting meaning to x;This makes no direct reference to syntax, but it makes reference to the semantic type associated with (the meanings of) syntactic nodes. Many contemporary semantic theories are type-driven in this sense. Types remove the necessity of mixing syntactic categories with semantic ones. Sentences/propositions and typesLast week we also suggested that propositions can be thought of as functions too: Basically, a proposition denotes either: The set of worlds in which it’s true; or A function from worlds to truth values Let’s restrict our attention to one world for now (our world, for example). This obviates the need to refer to several worlds. Viewed in this way, a proposition’s meaning is just a truth value. So it’s a different sort of semantic object from a predicate. Predicates are “incomplete”: they need to be saturated before they become propositions. Propositions are “complete” in the sense that they denote truth values. TPropositionFTypesA type system is a set of categories which are semantically motivated. For our purposes today, this has two uses: It allows us to specify restrictions on the kinds of things that can combine in certain ways, thus avoiding semantically anomalous combinations (but without need to mix syntactic and semantic categories). It allows us to distinguish between qualitatively different kinds of linguistic objects (such as predicates, names, and propositions), which denote different kinds of things. What types do we need?Suppose we distinguish between semantic objects depending on what sort of thing they denote: Names (paul) denote entities Predicates (sleep)are unsaturated propositions, functions from entities to truth values Propositions (Paul sleeps)denote truth values (ignoring the complication of possible worlds, for now). A simple type systemTo ensure that predicates get the right type of objects to saturate them, we could start by assuming that: Type eis the type of entities in our model – this is the type of things like Mary and Paul Type t is the type of truth values (i.e. of the values TRUE/1 and FALSE/0) – this is the type of things which can be true or false, i.e. Propositions (Paul sleeps) What about predicates, which are functions from things of type (1) to things of type (2)? Let’s think of predicates as having a complex type <e,t> This is just shorthand for “a function from entities to truth values” In terms of our modelOur model consists of a domain U and an interpretation function. If we assume: U is the domain of entities (type e) T is the set of truth values (i.e. {0,1}; type t) Then anything of type <e,t> is a function from things in U (of type e) to things in T (of type t) U(entities)Type eT (truth values)Type tType <e,t>A non-linguistic exampleIn maths, any numerical operation can be thought of as a function. Let f be a function such that f(x) = x2. In other words, this function is just the process of taking a number x and squaring it. f(2) = 22 = 4 Note that this is a function from numbers to numbers. Suppose we call the set of numbers N, and say that anything in N is of type e. Then, f is a function from things of type e to things of type e, that is, <e,e> F(x) = x2Another non-linguistic exampleWe know that we can define sets in terms of their characteristic functions: {x | x > 7} (the set of numbers greater than 7) Can be thought of as a function: The characteristic function of the set just returns true if an element is in the set, false otherwise. Once again, we define U as the domain of numbers, and assign these the type e. The above function takes something of type e(here, a number) and returns a truth value, which is of type t. So the type of the function is <e,t> Defining the type system recursivelyIn general, we could summarise what we’ve done using a small set of recursive rules: e is a type t is a type If a and b are types, then <a,b> (the function from things of type a to things of type b) is also a type. Nothing else is a type Note that (3) is recursive: given any two types (even complex ones), we can define a new complex type. We’ll see why this is useful soon. ConsequencesIn putting together the name pauland the predicate sleeps, we get a proposition. pauldenotes an entity, so it’s of type e sleeps denotes a predicate, so it’s of type <e,t> e[[paul]]: type e[[sleep]]: type <e,t>Putting something of type e into something of type <e,t> gives us back a truth value (of type t).The combination e + <e,t> is something that can be interpreted as a proposition, of type t.Extending this to n-place predicatesSo what about predicates like kill? Extensionally, this is a set of pairs (the killers and the killees) in our model. What’s the type of this predicate? (Think: what does this predicate need in order to become a proposition and return a truth value?) kill(x,y)N-place predicatesLet’s take it piece by piece: Mary killed John We can think of kill as a function that returns a truth value given two entities of type e. The syntax is helpful here: We have: An individual (the subject), combining with a predicate which itself needs to combine with another individual (kill + John) SMarykillJohnN-place predicatesIn order to be saturated, the transitive verb needs to: Combine with an individual (type e). This leaves an empty slot for a second individual. Once it combines with the second individual, it becomes a proposition. tkillMary<e,<e,t>>eJohneNB: note that we’re working from the inside out (starting with kill + John)Syntactic combination as function applicationRecall one of our interpretation rules from last week: If a node x has two daughters y and z, and [[y]] is an individual and [[z]] is a property, then saturate the meaning of z with the meaning of y and assign the resulting meaning to x;We can rework this rule as something like the following: If a node x has two daughters y and z and [[y]] is of type e and [[z]] is of type <e,t>, then: [[x]] = the result of applying the function [[z]] to the argument [[y]] [[x]] = [[z]]([[y]]) Thus: [[Paul sleeps]] is the result of applying the function [[sleep]] to the argument [[Paul]] [[sleeps]]([[paul]]) [[Mary killed John]] is the result of applying the function [[kill]]: first to [[John]] then to [[Mary]] [[kill]](john)(mary) Things to rememberOur recursive rule can construct complex types from simpler types: Given type a and type b, we construct type <a,b> This gave us <e,t> for predicates Things that combine with individuals (e) to yield propositions (t) For 2-place predicates, we take the types e and <e,t> and create a new complex type <e,<e,t>> Things that need an individual to yield a predicate that requires another individual for saturation. Our original interpretation rules for predicate saturation can be reinterpreted as function application. Part 2 The lambda calculusNaming a functionGiven what we’ve said so far, a verb like sleep can be viewed as a function which applies to an individual to return a truth value. In other words, predication is a form of function application. The problem is that compositional interpretation will now require lots of functions (every predicate is a function of some kind). Naming a functionThe usual way we define functions is contextually: Let f be a function from things in A to things in B (Correspondingly: Let f be a function from things of type a to things of type b) E.g. Let f be the function from numbers to numbers, f(x) = x2 Thus, f(2) = 4 An alternative is to use a system that would allow us to name functions on the fly: The lambda notation is a way of naming the function, which can now be applied to something of the right type: Naming a function: 1-place predicatesA one-place predicate can be represented as a function of this kind using lambda notation: This notation represents the function corresponding to sleep, which indicates that it requires some x to saturate it (and make it return a truth value). E.g.: tepaul<e,t>sleepNaming a function: 2-place predicatesWe can do the same with 2-place predicates Observe that the order of variables corresponds to the order in which we apply the function, first applying kill to the object, and then applying the result to the subject. tMarykill<e,<e,t>>eeJohnSyntax of lambda abstractionIf u is a variable of type a and ß is an expression of type b, then is an expression of type <a,b> In other words, we have a way of expressing complex types as functions. Semantics of lambda abstractionGiven u of type a, ß of type b, then is a function f from the set of things of type a to the set of things of type b, such that: For any object k of type a, where g’ is just like g except that g’(u) = k. (In other words, applying the function to the object returns the meaning of the original expression with the variable substituted for the object.) ExampleThis is that function fsuch that, for any number n, f(n) = n2. So, we find the value of the function, for the number 2 by: Assuming a variable assignment g’ whereby x = 2 Applying the body of the function to the value of x to give us the value 4. Note that the lambda expression names the function. What we have just done is apply the function to get its value. The lambda calculus allows us to distinguish the function itself from the set of values it returns. Example 2This is the function f such that, for some x of type e (say, the individual Paul), the function returns true just in case it is true in the model that that individual sleeps. To find the value for the individual Paul, we: Assume an assignment function g’ where g’(x) = Paul Apply the function sleep to Paul Check the truth value Lambda conversionThe process we’ve just seen entails: Setting the value of a variable Applying the function to the value Checking the result. This process is called lambda conversion Another exampleSuppose we set: x= paul y = mary We apply this as follows: We can then check the truth value of this proposition Notice that effectively, we have two function applications here. An exerciseExpress these predicates as lambda functions: smile (1-place) thin (1-place) eat (2-place) give (3-place) An exerciseWhat is their semantic type? smile (1-place) <e,t> thin (1-place) <e,t> eat (2-place) <e,<e,t>> give (3-place) <e,<e,<e,t>> Predicates vs modifiersWhat is the semantic difference of the use of tall in: The woman is tall Mary is a tall woman In the first case, tall is being predicated of an individual. Once saturated (i.e. once we apply the function), we get a truth value. In the second case, tall has a different use. Here, we first combine tall and woman, and then the resultng complex predicate can be applied to Mary to check if she’s indeed a tall woman. Can you think of the difference in terms of types?

Search Related

Previous Slide

Next Slide

Similar documents

We Need Your Support

Thank you for visiting our website and your interest in our free products and services. We are nonprofit website to share and download documents. To the running of this website, we need your help to support us.

Thanks to everyone for your continued support.

No, Thanks