test2.mdwn

   1 Here's what we did in seminar on Monday 9/13,
   2
   3 Sometimes these notes will expand on things mentioned only briefly in class, or discuss useful tangents that didn't even make it into class. These notes expand on *a lot*, and some of this material will be reviewed next week.
   4
   5 Applications
   6 ============
   7
   8 We mentioned a number of linguistic and philosophical applications of the tools that we'd be helping you learn in the seminar. (We really do mean "helping you learn," not "teaching you." You'll need to aggressively browse and experiment with the material yourself, or nothing we do in a few two-hour sessions will succeed in inducing mastery of it.)
   9
  10 From linguistics
  11 ----------------
  12
  13 *       generalized quantifiers are a special case of operating on continuations
  14
  15 *       (Chris: fill in other applications...)
  16
  17 *       expressives -- at the end of the seminar we gave a demonstration of modeling [[damn]] using continuations...see the [summary](/damn) for more explanation and elaboration
  18
  19 From philosophy
  20 ---------------
  21
  22 *       the natural semantics for positive free logic is thought by some to have objectionable ontological commitments; Jim says that thought turns on not understanding the notion of a "union type", and conflating the folk notion of "naming" with the technical notion of semantic value. We'll discuss this in due course.
  23
  24 *       those issues may bear on Russell's Gray's Elegy argument in "On Denoting"
  25
  26 *       and on discussion of the difference between the meaning of "is beautiful" and "beauty," and the difference between the meaning of "that snow is white" and "the proposition that snow is white."
  27
  28 *       the apparatus of monads, and techniques for statically representing the semantics of an imperatival language quite generally, are explicitly or implicitly invoked in dynamic semantics
  29
  30 *       the semantics for mutation will enable us to make sense of a difference between numerical and qualitative identity---for purely mathematical objects!
  31
  32 *       issues in that same neighborhood will help us better understand proposals like Kit Fine's that semantics is essentially coordinated, and that `R a a` and `R a b` can differ in interpretation even when `a` and `b` don't
  33
  34
  35
  36 Basics of Lambda Calculus
  37 =========================
  38
  39 The lambda calculus we'll be focusing on for the first part of the course has no types. (Some prefer to say it instead has a single type---but if you say that, you have to say that functions from this type to this type also belong to this type. Which is weird.)
  40
  41 Here is its syntax:
  42
  43 <blockquote>
  44 <strong>Variables</strong>: <code>x</code>, <code>y</code>, <code>z</code>...
  45 </blockquote>
  46
  47 Each variable is an expression. For any expressions M and N and variable a, the following are also expressions:
  48
  49 <blockquote>
  50 <strong>Abstract</strong>: <code>(&lambda;a M)</code>
  51 </blockquote>
  52
  53 We'll tend to write <code>(&lambda;a M)</code> as just `(\a M)`, so we don't have to write out the markup code for the <code>&lambda;</code>. You can yourself write <code>(&lambda;a M)</code> or `(\a M)` or `(lambda a M)`.
  54
  55 <blockquote>
  56 <strong>Application</strong>: <code>(M N)</code>
  57 </blockquote>
  58
  59
  60 Some authors reserve the term "term" for just variables and abstracts. We'll probably just say "term" and "expression" indiscriminately for expressions of any of these three forms.
  61
  62 Examples of expressions:
  63
  64         x
  65         (y x)
  66         (x x)
  67         (\x y)
  68         (\x x)
  69         (\x (\y x))
  70         (x (\x x))
  71         ((\x (x x)) (\x (x x)))
  72
  73 The lambda calculus has an associated proof theory. For now, we can regard the
  74 proof theory as having just one rule, called the rule of **beta-reduction** or
  75 "beta-contraction". Suppose you have some expression of the form:
  76
  77         ((\ a M) N)
  78
  79 that is, an application of an abstract to some other expression. This compound form is called a **redex**, meaning it's a "beta-reducible expression." `(\a M)` is called the **head** of the redex; `N` is called the **argument**, and `M` is called the **body**.
  80
  81 The rule of beta-reduction permits a transition from that expression to the following:
  82
  83         M [a:=N]
  84
  85 What this means is just `M`, with any *free occurrences* inside `M` of the variable `a` replaced with the term `N`.
  86
  87 What is a free occurrence?
  88
  89 >       An occurrence of a variable `a` is **bound** in T if T has the form `(\a N)`.
  90
  91 >       If T has the form `(M N)`, any occurrences of `a` that are bound in `M` are also bound in T, and so too any occurrences of `a` that are bound in `N`.
  92
  93 >       An occurrence of a variable is **free** if it's not bound.
  94
  95 For instance:
  96
  97
  98 >       T is defined to be `(x (\x (\y (x (y z)))))`
  99
 100 The first occurrence of `x` in T is free.  The `\x` we won't regard as being an occurrence of `x`. The next occurrence of `x` occurs within a form that begins with `\x`, so it is bound as well. The occurrence of `y` is bound; and the occurrence of `z` is free.
 101
 102 Here's an example of beta-reduction:
 103
 104         ((\x (y x)) z)
 105
 106 beta-reduces to:
 107
 108         (y z)
 109
 110 We'll write that like this:
 111
 112         ((\x (y x)) z) ~~> (y z)
 113
 114 Different authors use different notations. Some authors use the term "contraction" for a single reduction step, and reserve the term "reduction" for the reflexive transitive closure of that, that is, for zero or more reduction steps. Informally, it seems easiest to us to say "reduction" for one or more reduction steps. So when we write:
 115
 116         M ~~> N
 117
 118 We'll mean that you can get from M to N by one or more reduction steps. Hankin uses the symbol <code><big><big>&rarr;</big></big></code> for one-step contraction, and the symbol <code><big><big>&#8608;</big></big></code> for zero-or-more step reduction. Hindley and Seldin use <code><big><big><big>&#8883;</big></big></big><sub>1</sub></code> and <code><big><big><big>&#8883;</big></big></big></code>.
 119
 120 When M and N are such that there's some P that M reduces to by zero or more steps, and that N also reduces to by zero or more steps, then we say that M and N are **beta-convertible**. We'll write that like this:
 121
 122         M <~~> N
 123
 124 This is what plays the role of equality in the lambda calculus. Hankin uses the symbol `=` for this. So too do Hindley and Seldin. Personally, I keep confusing that with the relation to be described next, so let's use this notation instead. Note that `M <~~> N` doesn't mean that each of `M` and `N` are reducible to each other; that only holds when `M` and `N` are the same expression. (Or, with our convention of only saying "reducible" for one or more reduction steps, it never holds.)
 125
 126 In the metatheory, it's also sometimes useful to talk about formulas that are syntactically equivalent *before any reductions take place*. Hankin uses the symbol <code>&equiv;</code> for this. So too do Hindley and Seldin. We'll use that too, and will avoid using `=` when discussing metatheory for the lambda calculus. Instead we'll use `<~~>` as we said above. When we want to introduce a stipulative definition, we'll write it out longhand, as in:
 127
 128 >       T is defined to be `(M N)`.
 129
 130 We'll regard the following two expressions:
 131
 132         (\x (x y))
 133
 134         (\z (z y))
 135
 136 as syntactically equivalent, since they only involve a typographic change of a bound variable. Read Hankin section 2.3 for discussion of different attitudes one can take about this.
 137
 138 Note that neither of those expressions are identical to:
 139
 140         (\x (x w))
 141
 142 because here it's a free variable that's been changed. Nor are they identical to:
 143
 144         (\y (y y))
 145
 146 because here the second occurrence of `y` is no longer free.
 147
 148 There is plenty of discussion of this, and the fine points of how substitution works, in Hankin and in various of the tutorials we've linked to about the lambda calculus. We expect you have a good intuitive understanding of what to do already, though, even if you're not able to articulate it rigorously.