(no commit message)

[lambda.git] / topics / _week5_system_F.mdwn

diff --git a/topics/_week5_system_F.mdwn b/topics/_week5_system_F.mdwn
index 4afb43b..a7b4bb9 100644 (file)
--- 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 "<code>x:&alpha;</code>" represents an expression `x`
 whose type is <code>&alpha;</code>.
 
 course) that "<code>x:&alpha;</code>" represents an expression `x`
 whose type is <code>&alpha;</code>.
 

-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:
        ---------
 
        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
 
 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
 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
 (&alpha;, &beta;, etc.), or by using capital roman letters (X, Y,
 etc.).  "`τ1 -> τ2`" is the type of a function from expressions of
 can be distinguished by using letters from the greek alphabet
 (&alpha;, &beta;, 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
 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.
 
 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
 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 <code>&Lambda;</code> is a capital <code>&lambda;</code>: just
 like the lower-case <code>&lambda;</code>, <code>&Lambda;</code> binds
 abstraction*, and "`e [τ]`" is called a *type application*.  The idea
 is that <code>&Lambda;</code> is a capital <code>&lambda;</code>: just
 like the lower-case <code>&lambda;</code>, <code>&Lambda;</code> binds


@@ -70,9 +69,9 @@ variables in its body, except that unlike <code>&lambda;</code>,
 <code>&Lambda;</code> binds type variables instead of expression
 variables.  So in the expression
 
 <code>&Lambda;</code> binds type variables instead of expression
 variables.  So in the expression
 

-<code>&Lambda; α (&lambda; x:α . x)</code>
+<code>&Lambda; α (&lambda; x:α. x)</code>

 
 

-the <code>&Lambda;</code> binds the type variable `'a` that occurs in
+the <code>&Lambda;</code> binds the type variable `α` that occurs in

 the <code>&lambda;</code> 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
 the <code>&lambda;</code> 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:
 
 ready to apply this identity function to, say, a variable of type
 boolean, just do this:
 

-<code>(&Lambda; 'a (&lambda; x:'a . x)) [t]</code>    
+<code>(&Lambda; α (&lambda; x:α. x)) [t]</code>    

 
 This type application (where `t` is a type constant for Boolean truth
 
 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:
 
 surprisingly, the type of this type application is a function from
 Booleans to Booleans:
 

-<code>((&Lambda; 'a (&lambda; x:'a . x)) [t]): (b -> b)</code>    
+<code>((&Lambda;α (&lambda; x:α . x)) [t]): (b->b)</code>    

 
 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`:
 
 
 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`:
 

-<code>((&Lambda; 'a (&lambda; x:'a . x)) [e]): (e -> e)</code>    
+<code>((&Lambda;α (&lambda; x:α. x)) [e]): (e->e)</code>    

 
 

-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
 
 (polymorphic) identity function is
 

-<code>(&Lambda; 'a (&lambda; x:'a . x)): (&forall; 'a . 'a -> 'a)</code>
+<code>(&Lambda;α (&lambda;x:α . x)): (&forall;α. α-α)</code>

 
 Pred in System F
 ----------------
 
 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"):
 
 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)));
 
 
     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
 
 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
 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
 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.
  
 a concrete type built entirely from explicit base types, we'd be
 unable to proceed.
  


@@ -165,19 +165,19 @@ Typing &omega;
 In fact, unlike in the simply-typed lambda calculus, 
 it is even possible to give a type for &omega; in System F. 
 
 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:(All X. X->X) . x [All X . 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>
 
 
 In order to see how this works, we'll apply &omega; to the identity
 function.  
 
 <code>&omega; id ==</code>
 

-    (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 &omega;.  The definition of
 &omega; instantiates the identity function by binding the type
 right type to serve as the argument to &omega;.  The definition of
 &omega; 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.
 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.


@@ -228,10 +228,8 @@ uses.  Can we capture this using polymorphic types?
 
 With these basic types, we want to say something like this:
 
 
 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, it builds a function that
 
 The idea is that the basic *and* conjoins expressions of type `t`, and
 when *and* conjoins functional types, it builds a function that


@@ -258,7 +256,7 @@ 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
 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 'b will always itself be a complex type.
+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
 
 So conjunction and disjunction provide a compelling motivation for
 polymorphism in natural language, but we don't yet have the ability to