X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=topics%2F_week5_system_F.mdwn;h=0dcb0957803ffa0855c51e792a0c0979a4590683;hp=5b2e297c7a8929e9193c36d36375dbc59343bd36;hb=4d9fe4645917a4966694c7c4bf8edde8b243745f;hpb=2e1217b17ae7e408c89f52c4f6b43ce69284a342
diff --git a/topics/_week5_system_F.mdwn b/topics/_week5_system_F.mdwn
index 5b2e297c..0dcb0957 100644
--- a/topics/_week5_system_F.mdwn
+++ b/topics/_week5_system_F.mdwn
@@ -1,23 +1,13 @@
[[!toc levels=2]]
-# System F and recursive types
+# System F: the polymorphic lambda calculus
-In the simply-typed lambda calculus, we write types like σ
--> τ
. This looks like logical implication. We'll take
-that resemblance seriously when we discuss the Curry-Howard
-correspondence. In the meantime, note that types respect modus
-ponens:
-
-
-Expression Type Implication ------------------------------------ -fn α -> β α ⊃ β -arg α α ------- ------ -------- -(fn arg) β β -- -The implication in the right-hand column is modus ponens, of course. +The simply-typed lambda calculus is beautifully simple, but it can't +even express the predecessor function, let alone full recursion. And +we'll see shortly that there is good reason to be unsatisfied with the +simply-typed lambda calculus as a way of expressing natural language +meaning. So we will need to get more sophisticated about types. The +next step in that journey will be to consider System F. System F was discovered by Girard (the same guy who invented Linear Logic), but it was independently proposed around the same time by @@ -118,13 +108,14 @@ relevant evaluator is called "fullpoly"): 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 + + 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))); @@ -164,7 +155,7 @@ Typing ω In fact, unlike in the simply-typed lambda calculus, it is even possible to give a type for ω in System F. -
ω = λx:(âα.α->α).x [âα.α->α] x
+ω = λx:(âα.α->α). x [âα.α->α] x
In order to see how this works, we'll apply ω to the identity
function.