+...
+Here's a more elaborate example of the translation. Let's say we want to establish that combinators can reverse order, so we use the **T** combinator (`\x y. y x`):
+
+ [\x y. y x] =
+ [\x [\y. y x]] =
+ [\x. S [\y. y] [\y. x]] =
+ [\x. (SI) (K x)] =
+ S [\x. SI] [\x. K x] =
+ S (K(SI)) (S [\x. K] [\x. x]) =
+ S (K(SI)) (S(KK)I)
+-->
+
+(*Warning* This is a different mapping from the Lambda Calculus to Combinatory Logic than we presented in class (and was posted here earlier). It now matches the presentation in Barendregt 1984, and in Hankin Chapter 4 (esp. pp. 61, 65) and in Hindley & Seldin Chapter 2 (esp. p. 26). In some ways this translation is cleaner and more elegant, which is why we're presenting it.)
+
+In order to establish the correspondence, we need to get a bit more
+official about what counts as an expression in CL. Of course, we count
+the primitive combinators `S`, `K`, and `I` as expressions in CL. But
+we will also endow CL with an infinite stock of *variable symbols*, just like the lambda
+calculus, including `x`, `y`, and `z`. Finally, `(XY)` is in CL for any CL
+expressions `X` and `Y`. So examples of CL expressions include
+`x`, `(xy)`, `Sx`, `SK`, `(x(SK))`, `(K(IS))`, and so on. When we
+omit parentheses, we assume left associativity, so
+`XYZ ≡ ((XY)Z)`.
+
+It may seem weird to allow variables in CL. The reason this is
+necessary is because we're trying to show that *every* lambda term can
+be translated into an equivalent CL term. Since some lambda terms
+contain *free* variables, we need to provide a translation in CL for those free
+variables. As you might expect, it will turn out that whenever the
+lambda term in question contains *no* free variables (i.e., is a Lambda Calculus
+combinator), its translation in CL will *also* contain no variables, but will
+instead just be made up of primitive combinators and parentheses.
+
+Let's say that for any lambda term T, [T] is the equivalent Combinatory
+Logic term. Then we define the [.] mapping as follows.
+
+ 1. [a] = a
+ 2. [(\aX)] = @a[X]
+ 3. [(XY)] = ([X][Y])
+
+Wait, what is that `@a ...` business? Well, that's another operation on (a variable and) a CL expression, that we can define like this:
+
+ 4. @aa = I
+ 5. @aX = KX if a is not in X
+ 6. @a(Xa) = X if a is not in X
+ 7. @a(XY) = S(@aX)(@aY)
+
+Think of `@aX` as a pseudo-lambda abstract. (Hankin and Barendregt write it as <code>λ*a. X</code>; Hindley & Seldin write it as `[a] X`.) It is possible to omit line 6, and some presentations do, but Hindley & Seldin observe that this "enormously increases" the length of "most" translations.
+
+It's easy to understand these rules based on what `S`, `K` and `I` do.
+
+Rule (1) says that variables are mapped to themselves. If the original
+lambda expression had no free variables in it, then any such
+translations will only be temporary. The variable will later get
+eliminated by the application of other rules.
+
+Rule (2) says that the way to translate an application is to
+first translate the body (i.e., `[X]`), and then prefix a kind of
+temporary psuedo-lambda built from `@` and the original variable.
+
+Rule (3) says that the translation of an application of `X` to `Y` is
+the application of the translation of `X` to the translation of `Y`.
+
+As we'll see, the first three rules sweep through the lambda term,
+changing each lambda to an @.
+
+Rules (4) through (7) tell us how to eliminate all the `@`'s.
+
+In rule (4), if we have `@aa`, we need a CL expression that behaves
+like the lambda term `\aa`. Obviously, `I` is the right choice here.
+
+In rule (5), if we're binding into an expression that doesn't contain
+any variables that need binding, then we need a CL term that behaves
+the same as `\aX` would if `X` didn't contain `a` as a free variable.
+Well, how does `\aX` behave? When `\aX` occurs in the head position
+of a redex, then no matter what argument it occurs with, it throws
+away its argument and returns `X`. In other words, `\aX` is a
+constant function returning `X`, which is exactly the behavior
+we get by prefixing `K`.
+
+Rule (6) should be intuitive; and as we said, we could in principle omit it and just handle such cases under the final rule.
+
+The easiest way to grasp rule (7) is to consider the following claim:
+
+ \a(XY) <~~> S(\aX)(\aY)
+
+To prove it to yourself, just consider what would happen when each term is applied to an argument `a`. Or substitute `\x y a. x a (y a)` in for `S`
+and reduce.
+
+Persuade yourself that if the original lambda term contains no free
+variables --- i.e., is a Lambda Calculus combinator --- then the translation will
+consist only of `S`, `K`, and `I` (plus parentheses).
+