`A ⊃ B`

?
The question to ask here is whether our intuitions about what counts
as more evaluated always tracks simplicity of expression, or whether
it tracks what is more useful to us in a given larger situation.
But even deciding which expression ought to count as simpler is not
always so clear.
##Church arithmetic##
In our system of computing with Church encodings, we have the
following representations:
3 ≡ \f z. f (f (f z))
4 ≡ \f z. f (f (f (f z)))
7 ≡ \f z. f (f (f (f (f (f (f z))))))
The addition of `4` and `3`, then, clearly needs to just insert `3`'s string
of `f`s in front of `4`'s string of `f`s. That guides our
implementation of addition:
add ≡ \l r. \f z. r f (l f z)
add 4 3 ≡ (\l r. \f z. r f (l f z)) 4 3
~~> \f z. 3 f (4 f z)
≡ \f z. (\f z. f (f (f z))) f (4 f z)
~~> \f z. f (f (f (4 f z)))
≡ \f z. f (f (f ((\f z. f (f (f (f z))) f z))))
~~> \f z. f (f (f (f (f (f (f z))))))
≡ 7
as desired. Is there still a sense in which the encoded version of `add 4 3`
is simpler than the encoded version of `7`? Well, yes: once the
numerals `4` and `3` have been replaced with their encodings, the
encoding of `add 4 3` contains more symbols than the encoding of `7`.
But now consider multiplication:
mul ≡ \l r. \f z. r (l f) z
mul 4 3 ≡ (\l r. \f z. r (l f) z) 4 3
~~> \f z. 3 (4 f) z
≡ \f z. (\f z. f (f (f z))) (4 f) z
~~> \f z. (4 f) ((4 f) (4 f z))
≡ \f z. ((\f z. f (f (f (f z)))) f) (((\f z. f (f (f (f z)))) f) ((\f z. f (f (f (f z)))) f z))
~~> \f z. (\z. f (f (f (f z)))) ((\z. f (f (f (f z)))) (f (f (f (f z)))))
~~> \f z. (\z. f (f (f (f z)))) (f (f (f (f (f (f (f (f z))))))))
~~> \f z. f (f (f (f (f (f (f (f (f (f (f (f z)))))))))))
≡ 12
Is the final result simpler? This time, the answer is not so straightforward.
Compare the starting expression with the final expression:
mul 4 3
(\l r. \f z. r (l f) z) (\f z. f (f (f (f z)))) (\f z. f (f (f z))))
~~> 12
(\f z. f (f (f (f (f (f (f (f (f (f (f (f z))))))))))))
And if we choose different numbers, the result is even less clear:
mul 6 3
(\l r. \f z. r (l f) z) (\f z. f ( f (f (f (f (f z)))))) (\f z. f (f (f z))))
~~> 18
(\f z. f (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f (f z))))))))))))))))))
On the on hand, there are more symbols in the encoding of `18` than in
the encoding of `mul 6 3`. On the other hand, there is more complexity
(speaking pre-theoretically) in the encoding of `mul 6 3`, since the
encoding of `18` is just a uniform sequence of nested `f`s.
This example shows that computation can't be just simplicity as
measured by the number of symbols in the representation. There is
still some sense in which the evaluated expression is simpler, but the
right way to characterize "simpler" is elusive.
One possibility is to define simpler in terms of irreversability. The
reduction rules of the lambda calculus define an non-symmetric relation
over terms: for any given redex, there is a unique reduced term (up to
alphabetic variance). But for any given term, there will be many redexes
that reduce to that term.
((\x. x x) y) ~~> y y
((\x x) y y) ~~> y y
(y ((\x x) y)) ~~> y y
etc.
Likewise, in the arithmetic example, there is only one number that
corresponds to the sum of `4` and `3` (namely, `7`). But there are many
ways to add numbers to get `7`: `4+3`, `3+4`, `5+2`, `2+5`, `6+1`, `1+6`, `7+0` and `0+7`.
And that's only looking at sums.
So the unevaluated expression contains information that is missing
from the evaluated value: information about *how* that value was
arrived at. So this suggests the following way of thinking about what
counts as evaluated:
> Given two expressions such that one reduces to the other,
the more evaluated one is the one that contains less information.
This definition is problematic, though, if we try to define the amount
of information using, say, [[!wikipedia Komolgorov complexity]].
Ultimately, we have to decide that the reduction rules determine what
counts as evaluated. If we're lucky, that will align well with our
intuitive desires about what should count as simpler. But we're not
always lucky. In particular, although beta reduction in general lines
up well with our intuitive sense of simplification, there are
pathological examples where the results do not align so well:
(\x. x x) (\x. x x) ~~> (\x. x x) (\x. x x) ~~> (\x. x x) (\x. x x) ~~> ...
In this example, reduction returns the exact same lambda term. There
is no simplification at all. (As we mentioned in class, the term `(\x. x x)` is often referred to in these discussions as (little) `ω ω`

, displayed above, is called (big)