Cantor’s Diagonalisation Argument is Invalid

Photo by Daniel Hannah, via Pixabay https://pixabay.com/photos/water-bridge-sea-ocean-pier-3605013/

[ I wanted to use a trompe l’oeil for the picture, but I felt that I would be benefitting from someone else’s work (even if I could not find a prohibition against using it); this was my favourite — https://www.hughpryor.co.uk/697/ . Similarly for M. C. Escher. Ditto for this Escher-esque “photo” that some unnamed person has put a lot of work into — https://www.moillusions.com/wp-content/uploads/2010/10/escher-columns2.jpg. Also the Tardis. I quite liked this picture — https://pxhere.com/en/photo/98149 — but I could not rationalise it. ]

Cantor

[ Originally posted on LinkedIn on 2020.03.20.  • 2020.09.17 Significant editing around my now having more confidence about infinity, as follows.  ◦ Deleted section on quasi-infinite limit view.  I generally leave evidence of my imperfections, as evidence that I do not think I am always right, but this section significantly affected the readability.  ◦ I have a new argument on the simple infinity aspect; possibly I might have been fairly accused of ignoratio elenchi (Missing the Point).  (Again, including the incumbent argument would hurt readability.  Basically, it was a claim that the finite objection [ignores valid numerals] worked in the infinite universe.)  • Substantial rewrite (draft) posted on 2020.04.09.  Posted here on 2023.09.05. ]

[One should write for the right audience.  One might claim that I have aimed too low, herein.  Apart from the fact that I am myself not an expert in this area… I like to write for an audience for whom the material is new ground.  Apologies if my intent or execution is poor.]

Cantor’s Diagonalisation Argument — herein “CDA” — proves (rightly or wrongly) that… given a (putatively) complete list of all the real numbers, it is possible to find another number that is not in this list. That is… it (putatively) proves that it is not possible to have a complete list of the real numbers.  

The proof runs as follows. [I mark subscripts with “_” — e.g. “x_ji”.]

[There are any number of videos online explaining it. Most readers either • will already know it or • would be better off with one of those.]

Given a (putatively) complete list “x” of all the real numbers… consider a portion of the list that consists of numbers between 0 (inclusive is okay) and 1 (non-inclusive). We are assuming that the list is *not* in order; this improves clarity. We label the items in $x$… “x_1”, “x_2”, … .

x_1  0. 5 2 1 9 8 4 0 3 …
x_2  0. 7 3 0 2 1 4 9 7 …
x_3  0. 8 1 4 5 3 3 0 6 …
     …

We label each digit “d”, using subscripts — first for the item number in the list, and second for the ordinal number of the digit… as follows.

x_1  0. d_11 d_12 d_13 d_14 d_15 d_16 d_17 d_18 …
x_2  0. d_21 d_22 d_23 d_24 d_25 d_26 d_27 d_28 …
x_3  0. d_31 d_32 d_33 d_34 d_35 d_36 d_37 d_38 …
     …

Cantor’s process generates a [new] number between 0 and 1 (since the argument is about such numbers). Thus, this generated new number begins with “0.”. It is built by appending digits after the “0.”, one by one. There is a clever trick, but first let us get the core idea, as follows.

Cantor’s move is to work through a diagonal collection of digits — digit 1 from item $x_1$, digit 2 from item $x_2$ and so on — $d_11$, $d_22$, $d_33$, … . We append these digits to our new number, one by one. Taking the above illustration as an example, $d_11$ is 5, $d_22$ is 3, $d_33$ is 4, and so on. Thus, our new number is 0.534… , except that we have not done the trick yet.

Now for the trick. We are processing every item [every number] in the list, one by one. We are taking one digit from each number.. Cantor’s trick is to change each digit as we go. Particularly, we add 2 (mod 10, of course). In the above example, $d_11$ is 5, so we use 7; $d_22$ is 3, so we use 5; $d_33$ is 4, so we use 6. Thus, our new number is 0.756… .

Formally, then, we define “$y$” — the new number that we generate — as follows.

Let $y$ = 0. e_1 e_2 e_3 … where $e_i$ def= $d_ii$ + 2 (mod 10). [“def=” stands for “definitively =”.]

Our new number is different, in its 1st digit, from the 1st number… and is different in its 2nd digit from the 2nd number, and is different in its 3rd digit from the 3rd number… and so on. If we use “i” as a counter, then… for any item $x_i$, digit number $i$ [being $d_ii$] of our new number will be different from it.

Ostensibly, if we proceed to do this infinitely… we can be guaranteed that our new, generated number will be different from every item in an infinite list… and thus, ostensibly, this holds true even for an infinite list that is stipulated to be *complete*.

Rigorously… Cantor points out that, since • the number we are generating is a real number, and • $x$ is a complete list of all the real numbers… the number $y$ must exist in the list $x$ somewhere. [We are doing a reductio ad absurdum, so we are taking these tenets to be true at this point.] We call $y$’s position in the list $x$… “j”.

However, for any value for $j$ that we might try, we have a contradiction, as follows.

[Ostensibly, it makes no difference whether we use $i$ or $j$ as a counting or index variable. “$i$” and “$j$” are local variables used for counting. However, it aids clarity to consistently use “i” as a counter for the list $x$, and the digits in its members (since we only ever refer to the i’th digit in the i’th number), and “j” as an index for the position of $y$ in $x$, and (as for $i$) for the digits in $y$.]

$e_j$ = $d_jj$

$e_j$ = $d_jj$ + 2 (mod 10)

Cantor concluded that, since the number in $x$, that we identified as matching $y$, does not match $y$ after all — for any and every $j$ that we can try — this proves that $y$ is not a member of $x$ after all. That is… $y$ is a number that is not in the list $x$, even though the list $x$ was stipulated to be complete. The opening assumption that $x$ is a complete list is thus disproved.

Suspicions

There are several reasons to be suspicious of this argument.

One is that it is actually perfectly coherent to have a complete list of real numbers (as long as the list is infinite); there is no systematic or theoretical reason why an infinite list of real numbers would have to leave some out. (Which ones would it leave out, particularly?)

Another is that we can completely incapacitate the proof just by re-ordering the list $x$ before looking for the generated number $y$. That is… it is perfectly plausible that $y$ is indeed in the list; it is not a new *kind* of number.

Another is that the proof is a *reductio ad absurdum* that seems to contradict *itself*; it postulates that the number we generated represents a particular one in the list, and then ostensibly shows that we picked the wrong number.

(This turns out to be like the previous point.) Another is that it works even if there is no claim that the list is complete. That is… it is no surprise that we can prove that there is a number missing from a list that is not complete; what is surprising is that, even if we imagine that the number that we generate does happen to appear in an *incomplete* list, it still proves that there is an incoherence. Thus, it does seem to be about an incoherence to do with picking a number, rather than actually treating the case that the list is complete. This is especially interesting because — iteratively — the conclusion of the proof is that the list systematically can not be complete. It would follow that there was always a possibility that we end up with a number that we can not match with one in our list (glossing over the point that the proof is that we can not either way). In the special case that we can match a number, it proves that we did not. Again, it seems to be about matching a number, not about the question of whether or not the list is complete.

Reductio Ad Absurdum

This argument is an RAA (reductio ad absurdum). Thus, we begin with a set of premises/assumptions — assuming that these are indeed all true, if it needs to be said — and we show that the set of assumptions is incoherent.

The difficulty with an RAA argument is that it does not pick out which assumption is the one that is false. Arguably, any assumption that is doing any work in proving the incoherence is a candidate for being false. (Sometimes, in real life, it is obvious which one to blame, because the others are much more certain, but logically it can be any of the given assumptions.) That is, conversely, if the proof can be written without a given assumption, then… we can rewrite the proof without that assumption, and thus prove that — even if theoretically that assumption is false — one of the other assumptions is *also* false. The implication would be that we have no pertinent reason to believe that the assumption that we discarded was false; if we include it in our argument, it becomes a candidate for being false, but it is not doing any relevant work. Actually, it is theoretically possible to add literally absolutely *any* premise into a formal RAA argument, and position it as part of the final incoherence.

The point is that we can do precisely that with Cantor’s Diagonalisation Argument, with the assumption that it purports to disprove.

We are now going to run the argument without the assumption that the list is complete. If the incoherence depends on this assumption, then it will disappear. 

If we discard the assumption that the infinite list is complete, then, when we come to looking for a match for the generated number $y$, in the list of real numbers, then we may indeed not find a match in any given instance. Indeed, as already noted, this argument purports to prove that no infinite list of real numbers (extrapolating from the ones between 0 and 1) can be complete — it must be incomplete. It would follow that, when we launch the argument, with an assumptively complete list of numbers, we are actually missing some… so we might indeed not find a match in any given instance.

We can run the argument without requiring that the list $x$ be complete; we can imagine that, in the particular case in which we are running the argument, there is indeed a match for $y$ in the given list $x$ — this is a reasonable move. (Conversely, if we imagine that, in this particular case, $y$ happens to *not* match any of the items in the list $x$, then this is simply a failed run — the conditions that we need are not met — and we have to try again.)

Having run the argument, we get an incoherence [as below]. In Cantor’s Diagonalisation Argument, the premise that is (putatively) to blame is the premise/assumption that the list is complete. However, that is now not among our assumptions. We are forced to blame some other premise/assumption. (Again, the RAA argument does not tell us which one, but real-world knowledge can help with that.)

Again, given that the argument works — generates an incoherence — without this assumption, the real-world implication is that we should not include it and try to blame the incoherence on it.

The issue is whether or not the incoherence remains, so let us actually run through the argument formally.

We have an infinitely long, and fairly thorough (but not [necessarily] complete), list of real numbers $x$, from 0 inclusive to 1 exclusive. The list is not ordered. We go through the digits of these numbers, taking each digit $d_ii$, and progressively construct a new number $y$ by starting with “0.” and then progressively appending the digit $d_ii$ + 2 (mod 10). We take the result $y$, and look for a match amongst the items in the list $x$. We imagine that, in this particular run, we find one. We label the index of this item $j$. Now, we go through the digits of this number *x_j*. Sure enough, the value of the digit $d_jj$ is • on one account $d_jj$, and • on another account $d_jj$ + 2. This is incoherent.

Since we have not included the assumption that the list $x$ is complete, there is no possibility of blaming that assumption for this incoherence. Nonetheless, there is still the incoherence associated with trying any given number in the list $x$ as a match for the generated number $y$. Of course, that is precisely the purpose Cantor had in adding 2 to one digit from each number… and ostensibly this still shows that the list $x$ can not be complete. The result works for any list— we can not match $y$ with any item in the list — so arguably the result shows directly that we can generate an item that is not in the list, for *any* given list $x$… and *any* list arguably includes a *complete* list.

Actually, there is a conceptually simple, but well-hidden trick in this argument. I shall now explain that, systematically, the technique can generate a number that is not among the *treated* items in a list, but that it *does not treat every item*. It is quite obvious in the case of a finite (and complete) list, but of course not so obvious for an infinite list. The first aspect of this objection, then, is that the argument works with a finite list of length that approaches infinity, *as opposed to* a list that is simply infinite in length.

Cantor on a Finite List

Consider a complete list $x$ of 4-digit numbers — all the numbers from 0 to 9999, padded on the left with 0’s as necessary. These number 10,000. Suppose this we reorder this list randomly, and that, after this, the first 5 items are 4903, 0451, 7278, 2628 and 3945.

Using Cantor’s diagonalisation technique, we generate $y$ = 6690. We have treated 4 of the 10,000 numbers. We can guarantee that the number $y$ that we have generated is not among the first 4 numbers in the list $x$, because there is a different digit in each case. However, we can also guarantee that $y$ appears among the remaining 9996 numbers, because the list is complete (and it is possible to have a complete list of 4-digit numbers.) Note that we have treated 0.04% of the numbers in the list.

There is a simple, systematic problem here — being that, for each 1 digit that we write, there are 10 numbers in the list — multiplicatively — 10 times as many as for 1 fewer digits.

Consider, for instance, a complete list of 12-digit numbers, reordered. This includes all the numbers below 1,000,000,000,000 (padded with 0’s) — from 999,999,999,999 to 0 (inclusive). We generate a number $y$ — say 847,209,353,167. Our diagonal system processes 12 digits — one digit per line/item — thus covering 12 lines/items in the list. We can guarantee that there is no match for our number, among the first 12 numbers, but we can be certain that there will be a match for our number among the remaining 999,999,999,988 numbers, since the list is complete. For 12 digits, we have treated 0.0000000012% of the 1,000,000,000,000 numbers in the list $x$.

What is really going on with CDA is that it generates a number that does not have a match within a subset of the list $x$, and then insists that we look for a match only in that subset.

Of course, CDA is about an infinite list. Nonetheless, it uses the standard mathematical technique of working with some finite aspect of the infinite concept in question, and extrapolating from this. The objection obtains as long as this technique is allowed.

Before we look at the case of a list $x$ that actually is simply infinite, let us consider a possible way of rescuing the technique. 

Making the Technique Work

One wonders whether or not Cantor’s technique can be made to work (apart from relying on the magic of the concept of infinity) — whether we can somehow use it to treat a greater proportion of the list $x$.

The answer to that lies in the use of a different base. [The concept of base is as in… if we had 8 fingers instead of 10, we would be using base 8. (Of course, we would still write “10” for the number of fingers we had, but now that would mean “one more than 7” rather that “one more than 9”. Correspondingly, when we are *talking about* bases, and we refer to “base X”, we understand “X” as under normal base 10 — one more than 9.)] If we reduce our base, then we can reduce this proportion not treated.  

For any given base, adding 1 digit to the numbers in the list of numbers *multiplies* the number of items in the list by the size of the base. Consider base 10. If we have a list of 1-digit numbers, there are 10 (0 to 9). If we have a list of 2-digit numbers, there are 10 *times as many* (00 to 99). Ditto for 3 digits, and so on. Consider base 3. If we have a list of 1-digit numbers, there are 3 (0 to 2). If we have a list of 2-digit numbers, there are 3 times as many (00 to 22). Again, for each digit we add, the size of the list goes up by a *factor* related to the base. 

There is a limit case under which Cantor’s argument would work —hypothetically — being base 1. It works (hypothetically) because we finally get the number of free numbers down to 0. 

Let us use a list of 4-digit numbers to work through this. For base 10, there are 10 *times as many* considered lines in the list for each additional digit [or line] that we treat; we treat 4 items, and $y$ will be among the remaining (10^4)-4) = 9996 items. For base 3, there are 3 times as many considered lines in the list for each additional line that we treat; we treat 4 items, and $y$ will be among the remaining (3^4)-4) = 77 items. For base 2, there are only (2^4)-4) = 12 free items. For base 1, there are only (1^4)-4) = … $-3$ free items. (Note that that is a negative number.)  

The problem with the limit case of base 1 is that we have only 1 digit… and the convention is to include 0. Base 4 has {0,1,2,3}, base 3 has {0,1,2}, base 2 has {0,1} and base 1 would have only {0}. We can gloss over this, and label the one digit that we have “X”. The list of all numbers in base 1 would thus be X, XX, XXX and so on. (This is why we got -3 above; there, the list would comprise 0, 00, 000 and 0000.) (This suddenly looks familiar if we use “|” instead of “X”.) 

In this case, Cantor’s argument comes into its own, because/since we would have only 1 item in the list $x$ for each digit we treat. Now, $y$ would indeed be forced to be among the treated items. The difficulty is that the argument is now incoherent; it is no longer possible to generate a new digit that is different, since there is only the 1 digit. (Mathematically speaking… X + 2 mod 1 is X (although that would be written “X + XX mod X is X”, and this looks rather dubious).)

Insisting that $y$ must be in the first $n$ items in a list of 10^$n$ items works only in a case in which the core move is incoherent.

Finite vs Infinite

It is theoretically possible to apply Cantor’s Diagonalisation Argument to a list $x$ that we generate as we go, such that for any value of a counter $i$ it contains a randomly ordered, complete list of $i$-digit numbers between 0 inclusive and 1 non-inclusive (numbering 10^$i$). As we have seen, there will always be a large number of untreated items in the list.

That is not applicable, though. Cantor’s argument is about an (existing, randomly ordered) list that is infinitely long, and whose members are infinitely long (padding with 0’s as applicable). 

As it has been presented, Cantor’s method does not *directly* treat such a list. There is a whole mathematical school around using the mathematics of finite concepts to work with infinite concepts… by extrapolating. CDA uses a pertinent technique. It treats numbers of length that is finite but “approaches infinity”; it treats {a number of these} that is finite but approaches infinity. The result is secured by extrapolating, using this concept of a finite number that “approaches infinity”. (Again, the above objection is legitimate as long as the mathematical technique is legitimate.) 

Of course, if there were a 1:1 correspondence between {number of items treated} and {number of items considered in list} — which is how it is generally taken — it would show the result at every step… but that is very far from obtaining. Again… for any iteration of the proof — any instance of adding 1 digit to the number $y$ that is being generated — for a counter $i$, it treats $i$ numbers, and leaves (10^$i$)-$i$ untreated. As we have seen, this becomes sadly ridiculous very quickly. (This is linear growth (based on 1) versus exponential growth (based on 10). After (for instance) 100 iterations, we have 100 vs 10^100. $y$ is not among the first 100 items, but will be among the remaining 9,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999, 999,999,999,999,999,999,999,999,999,999,999,999,999,999,899 (or so) items.) 

Nonetheless, one might still wonder what it might look like, to apply Cantor’s conceptual approach to a list that comprises simply infinitely many numbers that are simply infinitely long (padded with 0’s as applicable). In other words… it is indeed initially plausible that the concept of {being complete} is not applicable to an infinitely long list of infinitely long numbers. 

[The remainder of the material in this subsection [on “simple infinity”] is possibly useful, in laying out the *question* thoroughly, but does not (otherwise) contribute to the *answer*; there is perhaps little loss in skipping to, “The point is that …”, just before the next section (“Countable”).]

Revision

We are discussing the case of an infinitely long list of infinitely long numbers, and I have claimed that the view that Cantor presupposes is about a number (finite in any instance) that approaches infinity — in the cases of both the number of digits and the number of items — as opposed to a simply infinitely long list of simply infinitely long numbers. Herein, I shall call the former case “approaches infinity”, and the latter “simple infinity”. [Conceptually, think of the former as, for instance, the number of integers ≥ 0, and the latter as, for instance, the number of points on an interval.]

In the step-by-step universe that CDA presupposes… we have seen that CDA fails to treat a portion of the list (and that this is such that the proportion treated tends towards 0 as we treat more).

Particularly, we can observe as follows — in the step-by-step universe. We have chosen a number, in the list $x$, that we are thinking matches $y$. We label its position $j$. It is consistent with CDA that every digit in this number, apart from the one at position $j$, does indeed match. According to CDA, however, there is a problem with the j’th digit; CDA states that, in position $j$, there are 2 possible values — that is, there *would be* 2 *actual* values *if this were* a match, and this is incoherent. We have seen that this purported incoherence arises from a systematic artificial restriction that excludes all ten of the numbers that match the above criterion, except one. [This appears meaningful and true to a reader escaping from the thrall of CDA; I have tried to render it such that it is true regardless, as much as possible, but it is qualified by the below observation about the audience deceiving themselves.] 

In the following few paragraphs, we take $i$ in the sense of being the last (i.e. most recent) of the item numbers that we have treated.

Recall that, for any given value for $i$, $j$ > $i$ — that is, $y$ is not in the treated area.

*Note carefully*… immediately here ignoring $y$… the value of the digit $d_ii$ is equal to the value of the digit $d_ii$; it is what it is. 

*Note carefully*… the value of the digit $d_jj$ is equal to the value of the digit $d_jj$; it is what it is.

*Note carefully*… the value of the digit in $y$, at digit position $i$ (with $i$ as defined above) is equal to $d_ii$ + 2 (mod 10). 

*Note carefully*… conversely to CDA’s claim, there *is* a number, further down the list $x$ than position $i$, that *will* match *all* the digits of $y$, including the i’th [as defined above] digit. The index of this number — $j$ — systematically *will* be greater than the largest value of $i$ that CDA has treated. 

As I have shown, there is no incoherence about the digits of this number $y$. The purported incoherence pertains to the digit $d_jj$, but only $i$ digits have been created, in the step-by-step process… and $i$ < $j$. $d_jj$ simply does not [yet] exist.

Cantor on an Infinite List

I have shown that Cantor’s Diagonalisation Argument [appeals to and] does not work in the “approaches infinity” case. Let us consider, then, the “simple infinity” case — a simply infinitely long list of simply infinitely long numbers, in some particular random order. Does CDA work in this universe of consideration?

[There is the difficulty here that we wish to use the counter $j$ to designate which number this is (and which digit we are considering, in this number). !*Spoiler Alert*! It turns out that $j$ pertains to the “approaches infinity” universe. In the genuinely infinite “simple infinity” universe, ostensibly $j$ would equal infinity, since there would be infinitely many numbers between 0 and any given real number. This does not matter to us, as we shall see.]

We have (somehow or other) worked our way through the entire infinitely long list of infinitely long numbers, and generated $y$. We have searched through the list $x$ and found $y$ at position $j$.

What can we say about this number, and the generation of it? If this case were the same as the “approaches infinity” case, we would expect to see the noted incoherence about the digit $e_j$, as follows. 

$e_j$ = $d_jj$

$e_j$ = $d_jj$ + 2 (mod 10)

Here (unlike in the “approaches infinity” case), with the length of the list and the lengths of its items both being “simply infinite”… it is initially plausible that actually every item is treated, and so it is no longer a fatal problem that each digit can have any one of 10 different values. In other words… it is initially plausible that… one can not claim that • the number of {items in the list} is greater than • the number of {digits in each item in the list}.

Conversely, it is initially plausible that… one can not claim that • the number of {items in the list} is *equal to* • the number of {digits in each item in the list}.

Normally, when dealing with “simple infinity”, we seek leverage in the “approaches infinity” universe of consideration… knowing that the results for that universe do apply to the “simply infinite” universe. [There are some contrary results, but we do not consider this to logically prove the approach to be generally invalid.]. We seek an anchor point, and we use mathematical tricks or techniques to extrapolate from this to the “simple infinity” picture (such as having two infinitely long lists that are offset by 1 item, and subtracting the matching items).

That is precisely what CDA is and does; it pertains to the “approaches infinity” view, and the idea is that the result does apply to the “simple infinity” picture. 

To discard the step-by-step approach of CDA that pertains to the “approaches infinity” universe of consideration, and look instead at a “simple infinity” picture, is a very significant move; it implies discarding the entire mathematical school to which the former pertains.

[Again] if we look at a “simple infinity” picture, it is possible to say neither that • all the numbers are treated nor that • *not* all the numbers are treated. All we have is a sea of digits. 

I shall argue that CDA does not succeed in this universe of consideration, but firstly let us note a point about CDA.

In CDA, as it has been *generally understood* — this including the step-by-step, “approaches infinity” element — there *were no* numbers that actually did match $y$ properly and fully. (This is indeed true, within the restricted domain that CDA entertains.) That is… under a *correct understanding*, there was a number further down the list $x$, that did match $y$ properly and fully, but CDA ignored this, and considered only the numbers that had been treated. However, the only connection these had with $y$ was that each one had 1 select digit that certainly *did not match* the corresponding digit in $y$. Each one was otherwise entirely arbitrary to $y$. That is, not a single one of them matched any digits in $y$, except strictly as a coincidence. 

Conversely, what we have done (in the “simple infinity” universe), is simply find the number, in the list $x$, that matches $y$ (properly and fully) (and labeled $j$ its position in $x$). 

Again… in CDA, as it has been generally understood, the whole point was that none of the available numbers matched $y$. Representatively, an entirely random one of these numbers (which was almost entirely arbitrary to $y$) was selected, and it was pointed out that we could say, of 1 particular digit, that it certainly *did not* match. Again, 1 digit *did not* match, and the remaining digits were strictly arbitrary. This representative case was then extrapolated to the entire list. Any thought that this system made a serious attempt at finding a number that closely matched $y$ was simply an artifact of the observer’s expectation that one of the numbers actually would match $y$ (which of course did obtain, under a correct understanding). 

Again, then… the exercise here has nothing whatsoever to do with the CDA technique of purportedly looking for [the] one exact match, whilst knowing beforehand that each and every considered candidate will turn out to have one digit that is out by 2. We have simply and straightforwardly looked for the number in the list $x$ that actually does match $y$.  

We have labeled its position $j$. 

Before we look to CDA for a verdict on our number $y$, let us imaginarily check its digits… since we know that CDA will assert that we got one wrong. …And yes, we are confident that we have the right number. 

Ostensibly, the core point of CDA, from the “approaches infinity” universe, *still does* obtain here… being that, in this found number that putatively matches $y$, we can still claim the shown incoherence in the digit in position $j$.

I have said that, in this “simple infinity” universe, we are in a position to say neither that • all the numbers are treated nor that • *not* all the numbers are treated. That is… there was an objection against CDA, and we find that we are in a position… neither to say that CDA is wrong, nor that it is right, in respect of that objection.

If CDA was *wrong*… when CDA pointed out that we had an error at digit $d_jj$, we could simply observe that we had actually made a mistake, and we could go and find the right number (further down), now successfully. [Actually, we would simply find the match for $y$… and that’s all. However, that lacks symmetry here.] 

If CDA was *right*… when CDA pointed out that we had an error at digit $d_jj$, we could suggest that we had actually made a mistake, and we could go and look for the right number, and it would turn out again that there was an incoherence — iteratively. 

This is perhaps an unsatisfying state in which to leave the discussion. Fortunately (albeit not for CDA), we can resolve this question.

As I said, we have discarded a whole mathematical school. 

The point of making this move of discarding a whole mathematical school was to rescue CDA. We found that CDA’s step-by-step method not only enabled the CDA proof but also enabled a fatal objection.

Unfortunately (for CDA), we can not rescue it by discarding this entire mathematical school, because CDA can not exist without it; CDA pertains to and uses and requires the mathematical school that is about the “approaches infinity” universe. 

Suppose that we imagine a random real number between 0 and 1. If we look for a match for this number, in an infinite list of all the real numbers between 0 and 1, we shall certainly find one/it. This would be true regardless, but CDA includes the premise that the list definitely is complete; it can not show this tenet to be false, using an RAA argument, unless it appears in the premises. If we presuppose the “simple infinity” universe of consideration, this is all we have — a random number that matches one in the complete list that we have.

CDA does not simply claim that the list is (also) *not* complete. Rather, it has a [putative] systematic proof of this — the RAA argument. Step-by-step, it takes one digit from each of the numbers in the (approaches-infinity-type) infinite list, and does something with this digit. 

The point is that *this is how $y$ in generated*. If we do not go through the step-by-step routine, imaginarily continued infinitely, we do not get our number $y$. Again, CDA is about a particular, special number $y$ that is generated in and using the step-by-step universe; every single digit of $y$ must be treated.

In the “approaches infinity” universe, CDA tries and fails. In the “simple infinity” universe, CDA can not exist in the first place.

It is still initially plausible that the concept of {being complete} is not applicable to an infinitely long list of infinitely long numbers. As noted, for every digit in the pertinent numbers, the list must be longer by a factor of 10 to be complete. I imagine that one finds this impressive subconsciously, even if one never has the concrete thought consciously. 

Nonetheless, it seems to me that the point is secured simply by observing that the list is infinitely long. It is not apparent how nor why the foregoing might be a problem. We can readily imagine a finitely long — and *complete* — list of finitely long numbers… and we can extrapolate an infinitely long list of infinitely long numbers from this, without in the slightest troubling the pertinent mathematical school. 

Countable

While I am here, I shall address also this idea that a complete list of the real numbers is uncountable… since — it seems to me — it probably seems plausible only because of Cantor’s “proof” (or perhaps CDA is *the* proof of this).  (It is accepted that some infinite lists are “countable”, so it is not merely about whether or not this is feasible in real life.)

In other words… as long as it is correct that the list of real numbers can be complete, it should be unnecessary to work through this, but I shall treat the point anyway.

The idea of (the members of) a list being countable depends on being able to assign, to each item in the list, an ordinal number (in a systematic way).

[

Suppose that, instead, we define “countable” to mean that each and every item in the list must have a unique identifier. We can achieve that by making each number its own identifier (so to speak).  √2 — √2 — check! √2-1 — √2-1 — check! 15.397029…[whatever it is] — 15.397029…[whatever it is] — check!  Overall… any number that we can identify is countable… and conversely any number that is not countable is beyond our reach anyway.  Given this… the concept of {a complete, infinite, countable list} is perfectly coherent.

I do not know if a professional mathematician would accept that.  (Actually, it is probably more a philosophical meta-mathematical question… which presumably means that it will not be written off completely.)

]

We can use the same kind of technique as is used for the rational numbers (for instance)… as follows.

It would be trivial to assign an ordinal number to each cardinal number, in order — fudging 0.  We start at 0 — we label that “0” (fudging).  [We could add 1 [not “1”] to each and every label to get a proper list of ordinal numbers, but this will do here.]  We proceed up to 9, labelling each one in turn.  Thus, for instance, 9 is labelled “9”.  Now we come to the second digit — the “tens” digit.  Correspondingly, we add another digit to our labels.  10 is thus “10”, and we proceed through to 19 (“19”) the same way.  Ectetera!

To adapt this system to the real numbers, we need two additional steps — one for the decimal point and one to include negative numbers.  The following system produces some numbers that are padded with 0’s, but (I take it that) duplicates can be dealt with, so I shall ignore this.

I shall leave the professional mathematicians and computer programmers to argue over exactly which label goes with exactly which number (and how to deal with that first 0 [that is, 0’s]… and the duplicates) — that is, in what order the numbers should be listed.  I believe that all I have do achieve here is to show that it is possible to generate a system that works as well as does the system for rational numbers.

As above, the root is a system that simply follows the cardinal numbers — A(0…9), B(0…9[A]), C(0…9[B]) and so on.

Given that, take the numeral sequence $0004827000$ as an example (noting that this is unusual in having many (contingently) non-significant 0’s).  For this item, we would count .0004827000, 0.004827000, 00.04827000, 000.4827000, 0004.827000, 00048.27000, 000482.7000, 0004827.000, 00048270.00, 000482700.0 and 0004827000… and then the same preceded by a “negative” sign.  (Again… this system produces duplicates with other numbers with fewer or more non-significant 0’s (as well as having .0, 0, -.0 and -0), but I take it that this is a solvable problem.)

Thus, the first few items would be as follows. 

.0, 0, -.0, -0, .1, 1, -.1, -1, .2, 2, -.2, -2, …, .9, 9, -.9, -9, .10, 1.0, 10, -.10, -1.0, -10, .11, 1.1, 11, -.11, -1.1, -11… and so on. 

Again, it is not that this is difficult; the issue is the theoretical question of whether or not this is legitimate… and, as I have observed, accepted mathematical techniques accommodate it effortlessly.