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=55f49aed384dbe64cf46446cf074500efd6eb30a;hb=4d9fe4645917a4966694c7c4bf8edde8b243745f;hpb=6d9219c32f63117d5e8dc1d9fc738c56b0cfcff5

diff --git a/topics/_week5_system_F.mdwn b/topics/_week5_system_F.mdwn
index 55f49aed..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 <code>&sigma;
--> &tau;</code>.  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: 
-
-<pre>
-Expression    Type      Implication
------------------------------------
-fn            &alpha; -> &beta;    &alpha; &sup; &beta;
-arg           &alpha;         &alpha;
-------        ------    --------
-(fn arg)      &beta;         &beta;
-</pre>
-
-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)));
 
@@ -137,7 +128,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 `∀ α . (α->α)->α->α`.  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
@@ -164,14 +155,14 @@ Typing &omega;
 In fact, unlike in the simply-typed lambda calculus, 
 it is even possible to give a type for &omega; in System F. 
 
-<code>&omega; = λlambda x:(∀ α. α->α) . x [∀ α . α->α] x</code>
+<code>&omega; = λx:(∀α.α->α). x [∀α.α->α] x</code>
 
 In order to see how this works, we'll apply &omega; to the identity
 function.  
 
 <code>&omega; id ==</code>
 
-    (λx:(∀α. α->α) . x [∀α.α->α] x) (Λα.λx:α. x)
+    (λx:(∀α.α->α). x [∀α.α->α] x) (Λα.λx:α.x)
 
 Since the type of the identity function is `∀α.α->α`, it's the
 right type to serve as the argument to &omega;.  The definition of