+At the same tme, though, it's natural to define `odd` in such a way that it hands off part of the work to `even`:
+
+ let odd = \x. iszero x
+ ; if x == 0 then result is
+ false
+ ; else result turns on whether x's pred is even
+ (even (pred x))
+
+Such a definition of `even` and `odd` is called **mutually recursive**. If you trace through the evaluation of some sample numerical arguments, you can see that eventually we'll always reach a base step. So the recursion should be perfectly well-grounded:
+
+ even 3
+ ~~> iszero 3 true (odd (pred 3))
+ ~~> odd 2
+ ~~> iszero 2 false (even (pred 2))
+ ~~> even 1
+ ~~> iszero 1 true (odd (pred 1))
+ ~~> odd 0
+ ~~> iszero 0 false (even (pred 0))
+ ~~> false
+
+But we don't yet know how to implement this kind of recursion in the lambda calculus.
+
+The fixed point operators we've been working with so far worked like this:
+
+ let X = Y T in
+ X <~~> T X
+
+Suppose we had a pair of fixed point operators, `Y1` and `Y2`, that operated on a *pair* of functions `T1` and `T2`, as follows:
+
+ let X1 = Y1 T1 T2 in
+ let X2 = Y2 T1 T2 in
+ X1 <~~> T1 X1 X2 and
+ X2 <~~> T2 X1 X2
+
+If we gave you such a `Y1` and `Y2`, how would you implement the above definitions of `even` and `odd`?
+
+
+<LI>(More challenging.) Using our derivation of Y from the [[Week2]] notes as a model, construct a pair `Y1` and `Y2` that behave in the way described.