We know, from member-nats-below-weak-better, that if (natp j) is true,
the member is equivalent to (and (natp k) (<= k j)). So now consider
what we know if (natp j) is false. If we can think of some term it's equivalent
to nd that term is simpler than the member expression, we have a strong rule.

But by inspection of the definition of nats-below, we see that when
(natp j) is false, (nats-below j) is the list (0) because (zp j)
is t. That is, nats-below treats all non-natural arguments like
they were 0. Thus, when (natp j) is false, (member k (nats-below j))
is (member k '(0)), which is (equal k 0).

This is a great :rewrite rule. It gets rid of the member and nats-below and
introduces arithmetic.

This example illustrates the idea of putting an if on the right-hand-side of the
equivalence. Many users tend to limit themselves to propositional forms inside
iff or to simple expressions inside of equal. But it is quite natural to
use if to express what the answer is: if j is a natural, then k is
in (nats-below j) precisely if k is a natural less than or equal to j;
if j is not a natural, then k is in (nats-below j) precisely if k is
0.

Use if to lay out the cases you must consider, if you can think of a simpler, equivalent
expression for every possible case.