In view of the discussions of the previous section, let’s agree for simplicity that the only propositions we’re interested in are ones that aren’t existentially quantified. I’ve claimed in this chapter, then, that a database certainly involves redundancy if it contains two distinct representations of the same proposition. In particular, we don’t want the same tuple to appear in two different places if those two appearances represent the same proposition. (Obviously we’d like to prohibit duplicate propositions as such; unfortunately, however, the DBMS doesn’t understand propositions as such.) But it’s all right for the same tuple to appear twice if those two appearances don’t represent the same proposition—and in any case we can have redundancy without any tuple appearing twice at all, as we’ve seen.

Normalization and orthogonality seem to be all we have by way of a scientific attack on the redundancy issue at the present time. Unfortunately, we’ve seen that normalization and orthogonality don’t solve the whole problem—they can reduce redundancy, but they can’t eliminate it entirely, in general. To be specific, we’ve seen several examples of designs that fully conform to the principles of normalization and orthogonality and yet display some redundancy, and those discussions were certainly far from exhaustive. We need more science! (Now I’ve told you that at least three times, and what I tell you three times is true.)

Given the foregoing state of affairs, it seems that redundancy will definitely exist in most databases. If it does:

Sadly, this last scenario is the one most likely to obtain in practice, given the state of today’s commercial implementations.