X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=test2.mdwn;h=062f6bfddf6ec3df20f4cf4c66d0db4c08c732d5;hp=a9178fb141c938655654cd125e544c324ff1882c;hb=fe4f7506b9e2821161136e88eb7d008d951cb666;hpb=2dd73ab29518785f2584259a41aa3efe49121237
diff --git a/test2.mdwn b/test2.mdwn
index a9178fb1..062f6bfd 100644
--- a/test2.mdwn
+++ b/test2.mdwn
@@ -1,3 +1,21 @@
+Here's what we did in seminar on Monday 9/13,
+
+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.
+
+Applications
+============
+
+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.)
+
+From linguistics
+----------------
+
+* generalized quantifiers are a special case of operating on continuations
+
+* (Chris: fill in other applications...)
+
+* 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
+
From philosophy
---------------
@@ -98,3 +116,33 @@ Different authors use different notations. Some authors use the term "contractio
M ~~> N
We'll mean that you can get from M to N by one or more reduction steps. Hankin uses the symbol `→`

for one-step contraction, and the symbol `↠`

for zero-or-more step reduction. Hindley and Seldin use `⊳`_{1}

and `⊳`

.
+
+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:
+
+ M <~~> N
+
+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.)
+
+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 `≡`

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:
+
+> T is defined to be `(M N)`.
+
+We'll regard the following two expressions:
+
+ (\x (x y))
+
+ (\z (z y))
+
+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.
+
+Note that neither of those expressions are identical to:
+
+ (\x (x w))
+
+because here it's a free variable that's been changed. Nor are they identical to:
+
+ (\y (y y))
+
+because here the second occurrence of `y` is no longer free.
+
+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.