X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=topics%2F_week5_system_F.mdwn;h=a7b4bb912333577b0afea0cb4f5ec855da96d566;hp=ff0b341bfb465da312e0fb2530627b10558da40f;hb=c98d4e2d9d0c85b16ac707323031114f2a3db1aa;hpb=b32335b5eb7ec1092798f3f77f4316b3709bfb8b diff --git a/topics/_week5_system_F.mdwn b/topics/_week5_system_F.mdwn index ff0b341b..a7b4bb91 100644 --- a/topics/_week5_system_F.mdwn +++ b/topics/_week5_system_F.mdwn @@ -34,35 +34,34 @@ notational convention (which will last throughout the rest of the course) that "x:α" represents an expression `x` whose type is α. -Then System F can be specified as follows (choosing notation that will -match up with usage in O'Caml, whose type system is based on System F): +Then System F can be specified as follows: System F: --------- - types τ ::= c | 'a | τ1 -> τ2 | ∀'a. τ - expressions e ::= x | λx:τ. e | e1 e2 | Λ'a. e | e [τ] + types τ ::= c | α | τ1 -> τ2 | ∀α.τ + expressions e ::= x | λx:τ.e | e1 e2 | Λα.e | e [τ] In the definition of the types, "`c`" is a type constant. Type constants play the role in System F that base types play in the simply-typed lambda calculus. So in a lingusitics context, type -constants might include `e` and `t`. "`'a`" is a type variable. The +constants might include `e` and `t`. "α" is a type variable. The tick mark just indicates that the variable ranges over types rather -than over values; in various discussion below and later, type variable +than over values; in various discussion below and later, type variables can be distinguished by using letters from the greek alphabet (α, β, etc.), or by using capital roman letters (X, Y, etc.). "`τ1 -> τ2`" is the type of a function from expressions of -type `τ1` to expressions of type `τ2`. And "`∀'a. τ`" is called a +type `τ1` to expressions of type `τ2`. And "`∀α.τ`" is called a universal type, since it universally quantifies over the type variable -`'a`. You can expect that in `∀'a. τ`, the type `τ` will usually -have at least one free occurrence of `'a` somewhere inside of it. +`'a`. You can expect that in `∀α.τ`, the type `τ` will usually +have at least one free occurrence of `α` somewhere inside of it. In the definition of the expressions, we have variables "`x`" as usual. -Abstracts "`λx:τ. e`" are similar to abstracts in the simply-typed lambda +Abstracts "`λx:τ.e`" are similar to abstracts in the simply-typed lambda calculus, except that they have their shrug variable annotated with a type. Applications "`e1 e2`" are just like in the simply-typed lambda calculus. In addition to variables, abstracts, and applications, we have two -additional ways of forming expressions: "`Λ'a. e`" is called a *type +additional ways of forming expressions: "`Λα.e`" is called a *type abstraction*, and "`e [τ]`" is called a *type application*. The idea is that Λ is a capital λ: just like the lower-case λ, Λ binds @@ -70,9 +69,9 @@ variables in its body, except that unlike λ, Λ binds type variables instead of expression variables. So in the expression -Λ 'a (λ x:'a . x) +Λ Î± (λ x:α. x) -the Λ binds the type variable `'a` that occurs in +the Λ binds the type variable `α` that occurs in the λ abstract. Of course, as long as type variables are carefully distinguished from expression variables (by tick marks, Grecification, or capitalization), there is no need to @@ -85,27 +84,27 @@ be adapted for use with expressions of any type. In order to get it ready to apply this identity function to, say, a variable of type boolean, just do this: -(Λ 'a (λ x:'a . x)) [t] +(Λ Î± (λ x:α. x)) [t] This type application (where `t` is a type constant for Boolean truth -values) specifies the value of the type variable `'a`. Not +values) specifies the value of the type variable `α`. Not surprisingly, the type of this type application is a function from Booleans to Booleans: -((Λ 'a (λ x:'a . x)) [t]): (b -> b) +((Λα (λ x:α . x)) [t]): (b->b) Likewise, if we had instantiated the type variable as an entity (base type `e`), the resulting identity function would have been a function of type `e -> e`: -((Λ 'a (λ x:'a . x)) [e]): (e -> e) +((Λα (λ x:α. x)) [e]): (e->e) -Clearly, for any choice of a type `'a`, the identity function can be -instantiated as a function from expresions of type `'a` to expressions -of type `'a`. In general, then, the type of the uninstantiated +Clearly, for any choice of a type `α`, the identity function can be +instantiated as a function from expresions of type `α` to expressions +of type `α`. In general, then, the type of the uninstantiated (polymorphic) identity function is -(Λ 'a (λ x:'a . x)): (∀ 'a . 'a -> 'a) +(Λα (λx:α . x)): (∀α. α-α) Pred in System F ---------------- @@ -117,15 +116,16 @@ however. Here is one way, coded in System F|http://www.cis.upenn.edu/~bcpierce/tapl/index.html]] (the relevant evaluator is called "fullpoly"): - N = All X . (X->X)->X->X; - Pair = (N -> N -> N) -> N; - let zero = lambda X . lambda s:X->X . lambda z:X. z in - let fst = lambda x:N . lambda y:N . x in - let snd = lambda x:N . lambda y:N . y in - let pair = lambda x:N . lambda y:N . lambda z:N->N->N . z x y in - let suc = lambda n:N . lambda X . lambda s:X->X . lambda z:X . s (n [X] s z) in - let shift = lambda p:Pair . pair (suc (p fst)) (p fst) in - let pre = lambda n:N . n [Pair] shift (pair zero zero) snd in + N = ∀α.(α->α)->α->α; + Pair = (N->N->N)->N; + + let zero = Λα. λs:α->α. λz:α. z in + let fst = λx:N. λy:N. x in + let snd = λx:N. λy:N. y in + let pair = λx:N. λy:N. λz:N->N->N. z x y in + let suc = λn:N. Λα. λs:α->α. λz:α. s (n [α] s z) in + let shift = λp:Pair. pair (suc (p fst)) (p fst) in + let pre = λn:N. n [Pair] shift (pair zero zero) snd in pre (suc (suc (suc zero))); @@ -138,7 +138,7 @@ lambda). The key to the extra expressive power provided by System F is evident in the typing imposed by the definition of `pre`. The variable `n` is -typed as a Church number, i.e., as `All X . (X->X)->X->X`. The type +typed as a Church number, i.e., as `∀α.(α->α)->α->α`. The type application `n [Pair]` instantiates `n` in a way that allows it to manipulate ordered pairs: `n [Pair]: (Pair->Pair)->Pair->Pair`. In other words, the instantiation turns a Church number into a @@ -151,8 +151,8 @@ that the ordered pairs we need here are pairs of numbers. If we tried to replace the type for Church numbers with a concrete (simple) type, we would have to replace each `X` with the type for Pairs, `(N -> N -> N) -> N`. But then we'd have to replace each of these `N`'s with the -type for Church numbers, `(X -> X) -> X -> X`. And then we'd have to -replace each of these `X`'s with... ad infinitum. If we had to choose +type for Church numbers, `(α -> α) -> α -> α`. And then we'd have to +replace each of these `α`'s with... ad infinitum. If we had to choose a concrete type built entirely from explicit base types, we'd be unable to proceed. @@ -165,19 +165,19 @@ Typing ω In fact, unlike in the simply-typed lambda calculus, it is even possible to give a type for ω in System F. -ω = lambda x:(All X. X->X) . x [All X . X->X] x +ω = λx:(∀α.α->α). x [∀α.α->α] x In order to see how this works, we'll apply ω to the identity function. ω id == - (lambda x:(All X . X->X) . x [All X . X->X] x) (lambda X . lambda x:X . x) + (λx:(∀α.α->α). x [∀α.α->α] x) (Λα.λx:α.x) -Since the type of the identity function is `(All X . X->X)`, it's the +Since the type of the identity function is `∀α.α->α`, it's the right type to serve as the argument to ω. The definition of ω instantiates the identity function by binding the type -variable `X` to the universal type `All X . X->X`. Instantiating the +variable `α` to the universal type `∀α.α->α`. Instantiating the identity function in this way results in an identity function whose type is (in some sense, only accidentally) the same as the original fully polymorphic identity function. @@ -203,7 +203,7 @@ Turing complete. ## Polymorphism in natural language Is the simply-typed lambda calclus enough for analyzing natural -language, or do we need polymorphic types (or something even more expressive)? +language, or do we need polymorphic types? Or something even more expressive? The classic case study motivating polymorphism in natural language comes from coordination. (The locus classicus is Partee and Rooth @@ -218,9 +218,9 @@ In English (likewise, many other languages), *and* can coordinate clauses, verb phrases, determiner phrases, transitive verbs, and many other phrase types. In a garden-variety simply-typed grammar, each kind of conjunct has a different semantic type, and so we would need -an independent treatment of *and* for each one. Yet there is a strong -intuition that the contribution of *and* remains constant across all -of these uses. Can we capture this using polymorphic types? +an independent rule for each one. Yet there is a strong intuition +that the contribution of *and* remains constant across all of these +uses. Can we capture this using polymorphic types? Ann, Bill e left, slept e -> t @@ -228,51 +228,53 @@ of these uses. Can we capture this using polymorphic types? With these basic types, we want to say something like this: - and:t->t->t = lambda l:t . lambda r:t . l r false - and = lambda 'a . lambda 'b . - lambda l:'a->'b . lambda r:'a->'b . - lambda x:'a . and:'b (l x) (r x) + and:t->t->t = λl:t. λr:t. l r false + and = Λα.Λβ.λl:α->β.λr:α->β.λx:α. and [β] (l x) (r x) The idea is that the basic *and* conjoins expressions of type `t`, and -when *and* conjoins functional types, the result is a function that -distributes its argument across the two conjuncts and conjoins the -result. So `Ann left and slept` will evaluate to `(\x.and(left -x)(slept x)) ann`. Following Partee and Rooth, the strategy of -defining the coordination of expressions with complex types in terms -of the coordination of expressions with less complex types is known as -Generalized Coordination. +when *and* conjoins functional types, it builds a function that +distributes its argument across the two conjuncts and conjoins the two +results. So `Ann left and slept` will evaluate to `(\x.and(left +x)(slept x)) ann`. Following the terminology of Partee and Rooth, the +strategy of defining the coordination of expressions with complex +types in terms of the coordination of expressions with less complex +types is known as Generalized Coordination. But the definitions just given are not well-formed expressions in -System F. There are several problems. The first is that we have two +System F. There are three problems. The first is that we have two definitions of the same word. The intention is for one of the definitions to be operative when the type of its arguments is type -`t`, but we have no way of conditioning evaluation on the type of an +`t`, but we have no way of conditioning evaluation on the *type* of an argument. The second is that for the polymorphic definition, the term *and* occurs inside of the definition. System F does not have -recursion. The third problem is more subtle. The defintion as given -takes two types as parameters: the type of the first argument expected -by each conjunct, and the type of the result of applying each conjunct -to an argument of that type. We would like to instantiate the -recursive use of *and* in the definition by using the result type. -But fully instantiating the definition as given requires type -application to a pair of types, not just one type. +recursion. + +The third problem is more subtle. The defintion as given takes two +types as parameters: the type of the first argument expected by each +conjunct, and the type of the result of applying each conjunct to an +argument of that type. We would like to instantiate the recursive use +of *and* in the definition by using the result type. But fully +instantiating the definition as given requires type application to a +pair of types, not to just a single type. We want to somehow +guarantee that β will always itself be a complex type. So conjunction and disjunction provide a compelling motivation for polymorphism in natural language, but we don't yet have the ability to build the polymorphism into a formal system. And in fact, discussions of generalized coordination in the -linguistics literature are almost always left as a metageneralization -over a basic simply-typed grammar. For instance, in Hendriks' 1992:74 -dissertation, generalized coordination is implemented as a method for -generating a suitable set of translation rules, which are in turn -expressed in a simply-typed grammar. +linguistics literature are almost always left as a meta-level +generalizations over a basic simply-typed grammar. For instance, in +Hendriks' 1992:74 dissertation, generalized coordination is +implemented as a method for generating a suitable set of translation +rules, which are in turn expressed in a simply-typed grammar. -Not incidentally, we're not aware of any programming language that +Not incidentally, we're not aware of any programming language that makes generalized coordination available, despite is naturalness and ubiquity in natural language. That is, coordination in programming -languages is always at the sentential level. You might be able to evaluate -`delete file1 and delete file2` but never `delete file1 and file2`. +languages is always at the sentential level. You might be able to +evaluate `(delete file1) and (delete file2)`, but never `delete (file1 +and file2)`. We'll return to thinking about generalized coordination as we get deeper into types. There will be an analysis in term of continuations