2e:null 2f:["$","title",null,{"children":"Infinite Binary Tree of Intervals | Daniel LaLiberte | Observable"}] 34:T5b1,

Infinite Binary Tree of Half-Open Intervals

Level	Infinite Binary Tree of Half-Open Intervals
0	[0, 1)
1	[0, .1)					[.1, 1)
2	[0, .01)			[.01, .10)		[.10, .11)		[.11, 1)
3	[0, .001)		[.001, .010)	[.010, .011)	[.011, .100)	[.100, .101)	[.101, .110)	[.110, .111)	[.111, 1)
...	[0, ...)	...								[..., 1)
${tex`\omega`}	[0, ${tex`\epsilon`})	...			[r, r+${tex`\epsilon`})	[r+${tex`\epsilon`}, r+${tex`2\epsilon`})	...			[1-${tex`\epsilon`}, 1)

35:T814,

Infinite Binary Tree of Closed Intervals

Level	Infinite Binary Tree of Closed Intervals
0	[0, 1]
1	[0, .1]						[.1, 1]
2	[0, .01]			[.01, .10]			[.10, .11]			[.11, 1]
3	[0, .001]		[.001, .010]	[.010, .011]	[.011, .100]		[.100, .101]		[.101, .110]	[.110, .111]	[.111, 1]
...	[0, ...]	...										[..., 1]
"${tex`\infty`}"	[0, 0]	??? ...			[r, r]	[r, r]	[r, r]	[r, r]	... ???			[1, 1]

36:T7ab,#### An Infinite Sequence of Contiguous Closed Intervals over `[0, 1]` We can also traverse the infinite binary tree of closed intervals in a breadth-first order to construct an infinite sequence of levels where each level is a set of contiguous closed intervals. The first element of this sequence is at level 0 of the tree, and it is a sequence containing the root node representing the closed interval `[0, 1]`. The second element of the sequence of levels is level 1, which will have two intervals, `[0, 1/2]` and `[1/2, 1]`. Each subsequent element of the sequence of levels is derived from the previous element by subdividing each interval into two intervals of half the width. The set of intervals in each element of this sequence of levels are contiguous, meaning every interval has one or two neighboring intervals that share an endpoint. Consequently, the union of all the intervals at each level is always identical to the whole interval `[0, 1]`. Each subsequent element of this sequence is a set with double the number of intervals, each with half the width of the intervals in the previous element. The "limit" of this sequence of sets of intervals should be a set with a countable infinity of intervals that remain contiguous and cover the whole interval `[0, 1]`. The width of each interval at the limit would be 0, by the normal definition of a limit, since the width of intervals at subsequent levels is half the width of the intervals of the previous level, and ${tex`\lim_{n\to\infty}{1/2^n} = 0`}. But even an infinite number of `0`-width intervals won't add up to the whole interval `[0, 1]` with non-zero width, so already we have a contradiction. Note that "limit" is quoted in the previous paragraph. This is because the limit of a sequence of things that are not numbers is not necessarily well defined. But how exactly should we define the limit of a sequence of entities so that we can avoid this kind of contradiction?37:T45d,Given this contradiction, there are a few possibilities for resolving or avoiding it: 1. There are no intervals at the limit of the infinite binary tree of closed intervals, just as there are no digits at the limit of the infinite binary tree of digits. But it seems that the limit of the tree of intervals _should be_ a set of intervals such that the union of all the intervals is all real numbers between 0 and 1. 2. The infinite complete binary tree of closed intervals might be undefined at the limit. But why is it that, when we replace the digit for each node with a closed interval, we get a contradiction which leads us to believe that the limit is undefined? 3. The definition of the limit of a sequence of nested closed intervals might not be merely a single number. On the other hand, the two endpoints of the interval at the limit cannot be two different real numbers. None of these choices seems entirely satisfactory, so let's reexamine the argument a little more closely to see if can identify where the underlying problem is, and maybe then we will have better understanding of how we could fix it.38:T58a, At level 0 of the tree, the root node value will be the half-open interval of real numbers `[0, 1)`. Note that the right endpoint of the half-open interval `[0, 1)` is `1` even though `1` is excluded from the interval. At level 1, the two subintervals are `[0, 1/2)` and `[1/2, 1)`. The intersection of these subintervals is the empty set since `1/2` is excluded from the first interval but is included in the second interval. The two subintervals nevertheless share the endpoint `1/2`. For each subsequent level of the binary tree, we will subdivide each interval from the previous level into two subintervals, as before. Every interval will have two neighboring intervals that it shares an endpoint with, except for the first and last intervals which only have one neighboring interval. The union of all the half-open intervals on each level of the binary tree is always `[0, 1)` and the intersection is always empty. For every pair of neighboring intervals, `[r, s)` and `[s, t)`, the two left-closed endpoints, `r` and `s`, can be different numbers. In other words, **the right-open side of every interval at every level allows the left-closed endpoints of every pair of neighboring intervals to be different**. This means that each neighboring pair of intervals can share an endpoint at every level, even at the limit, and thus we will avoid the contradiction that arises when using closed intervals.39:T5b1,

Infinite Binary Tree of Half-Open Intervals

Level	Infinite Binary Tree of Half-Open Intervals
0	[0, 1)
1	[0, .1)					[.1, 1)
2	[0, .01)			[.01, .10)		[.10, .11)		[.11, 1)
3	[0, .001)		[.001, .010)	[.010, .011)	[.011, .100)	[.100, .101)	[.101, .110)	[.110, .111)	[.111, 1)
...	[0, ...)	...								[..., 1)
${tex`\omega`}	[0, ${tex`\epsilon`})	...			[r, r+${tex`\epsilon`})	[r+${tex`\epsilon`}, r+${tex`2\epsilon`})	...			[1-${tex`\epsilon`}, 1)

3a:T7ee,The infinite complete binary tree of half-open intervals has a countable infinity of levels and a countable infinity of intervals at the limit. This is well understood and agreed to by mathematicians, at least for the infinite complete binary tree of digits, and the same should be true for the binary tree of intervals since there are the same number of nodes. The smallest infinite cardinality is the cardinality of the countable set of Naturals. In Hyperreal math, this smallest infinity is typically called ${tex`\omega`} (omega), and the largest infinitesimal is called ${tex `\epsilon`} (epsilon), where ${tex `\epsilon = 1 / \omega`}. We can compute the width of each interval at the limit of this infinite binary tree of half-open intervals, by dividing the total width of the whole interval `[0, 1)` which is ${tex `(1 - 0)`} by the number of intervals which is ${tex`\omega`}. So ${tex `(1 - 0) / \omega = 1 / \omega = \epsilon`}. Equivalently, ${tex`\epsilon * \omega = 1`}. In other words, each interval at the limit of the infinite binary tree of half-open intervals has a width of one infinitesimal. The gap between the left endpoint and the right endpoint of each infinitesimal interval is one infinitesimal. There is no other real number between these endpoints, so there is at most one real number in each infinitesimal interval. Regarding the cardinality of the Reals, we can conclude the following things from the infinite binary tree of half-open intervals. 1. The union of the infinitesimal intervals at the limit of the infinite binary tree of half-open intervals is the same as `[0, 1)`, so no real number could have been excluded. 2. The right endpoint of each half-open interval is excluded from the interval, so each half-open infinitesimal interval can contain no more than one real number. 3. The cardinality of this set of infinitesimal intervals is the same as the cardinality of the Naturals. 4. Therefore, the cardinality of the Reals can be no more than the cardinality of the Naturals.3b:T912,### One Infinitesimal is Strictly Smaller than any Positive Real Since ${tex`\epsilon`} is defined, in Hyperreal math, as greater than 0 but strictly smaller than any real number, this raises yet another problem. Since each of the infinitesimal intervals is smaller in width than the value of any real, at least there is no risk that any infinitesimal interval might contain more than one real, even if some might be empty. But if ${tex`\epsilon`} is strictly smaller than any real, that implies ${tex`\epsilon * \omega < 1`}, which would mean that a width of ${tex`\epsilon`} for each of the ${tex`\omega`} intervals would not be large enough to cover the entire interval `[0, 1)`. Or perhaps there must be more than ${tex`\omega`} intervals. But worse, the definition of the Hyperreals would be inconsistent with this conclusion since ${tex`\epsilon`} is defined such that ${tex `\epsilon = 1 / \omega`} and not ${tex `\epsilon < 1 / \omega`}. Maybe this exposes another contradiction, or perhaps it is just a matter of defining how the Reals and Hyperreals relate such that we avoid this contradiction. To be consistent, maybe we should simply decide that an infinitesimal is smaller than _or equal to_ any real number greater than 0. And since we want ${tex`\epsilon * \omega`} to be exactly equal to `1`, that would mean **one infinitesimal, ${tex`\epsilon`}, must be equal to the smallest real**. Note that we can still distinguish between infinitesimals and finite real numbers, such that there is no smallest *finite* real number, and ${tex`\epsilon`} is strictly less than any *finite* real number. Rather than distinguishing Reals and HyperReals, it might be simpler to switch to HyperReals, where the finite Reals are just the subset of Hyperreals of degree `0`, since ${tex`\epsilon^0 = \omega^0 = 1`}. 3c:T6cc,1. At the limit of this binary tree of half-open intervals, we have a countable infinity of infinitesimally small intervals that cover the entire interval of reals, `[0, 1)`. All rational and irrational real numbers in the interval `[0, 1)` must be included in this interval. We already showed that this list of infinitesimally small intervals at the limit is countable, but we can go a step further. 2. Each path through this binary tree of intervals, starting from the root down toward the limit, corresponds to an infinite sequence of nested half-open intervals that, at the limit in Reals, results in an _infinitesimally small interval_ that corresponds to a singleton set of one unique real number in the interval `[0, 1`), or it might be an empty set. (Any path ending with an infinite number of right branch intervals will have a limit that is the empty set, since it corresponds to a real number with an infinite tail of `1` digits that is equivalent to the "next" number with an infinite tail of `0` digits.) These two points together mean that every real number in the interval `[0, 1)` corresponds uniquely to one of the countable infinity of infinitesimally small intervals at the limit of the binary tree of intervals, and vice versa (ignoring the empty sets). Consequently, the Reals must be countable. Furthermore, we can enumerate the Reals represented by this infinite binary tree of half-open intervals, as discussed below. This proof came out of the argument presented in the Refutation of Cantor's Diagonalization which constructs an infinite tree of subdivisions of an enumeration of reals to show that the diagonalization argument no longer applies at the limit where each subdivision has only one real number. 3d:T859,

Infinite Binary Tree of Half-Open Intervals of Hyperreals for the Interval ${tex`[0, 1\epsilon)`}

Level	Infinite Binary Tree of Half-Open Intervals of Hyperreals for the Interval ${tex`[0, 1\epsilon)`}
0	[0, 1${tex`\epsilon`})
1	[0, .1${tex`\epsilon`})					[.1${tex`\epsilon`}, 1${tex`\epsilon`})
2	[0, .01${tex`\epsilon`})			[.01${tex`\epsilon`}, .10${tex`\epsilon`})		[.10${tex`\epsilon`}, .11${tex`\epsilon`})		[.11${tex`\epsilon`}, 1${tex`\epsilon`})
3	[0, .001${tex`\epsilon`})		[.001${tex`\epsilon`}, .010${tex`\epsilon`})	[.010${tex`\epsilon`}, .011${tex`\epsilon`})	[.011${tex`\epsilon`}, .100${tex`\epsilon`})	[.100${tex`\epsilon`}, .101${tex`\epsilon`})	[.101${tex`\epsilon`}, .110${tex`\epsilon`})	[.110${tex`\epsilon`}, .111${tex`\epsilon`})	[.111${tex`\epsilon`}, 1${tex`\epsilon`})
...	[0, ...)	...								[..., 1${tex`\epsilon`})
${tex`\omega`}	[0, ${tex`\epsilon^2`})	...			[r, r+${tex`\epsilon^2`})	[r+${tex`\epsilon^2`}, r+${tex`2\epsilon^2`})	...			[1${tex`\epsilon`}-${tex`\epsilon^2`}, 1${tex`\epsilon`})

3e:T85e,## Enumeration of Nodes of Infinite Binary Tree of Intervals Defines a "Rational" Enumeration of Reals Since we have a countable infinity of infinitesimal intervals that cover the entire interval `[0, 1)`, and the limit of each unique infinite sequence of nested intervals constructed from a path through the tree is one real number, and all real numbers are thus accounted for at the limit of the binary tree, this implies the cardinality of the real numbers must be countable. Furthermore, we can enumerate the Reals represented by this infinite binary tree of half-open intervals in one of two ways: 1. We can enumerate the countable infinity of leaf nodes at the limit of the tree which represent infinitesimal intervals, in order from lowest to highest. This is equivalent to a sequence defined by multiplying ${tex`\epsilon`} by successive natural numbers, ${tex`r_n = n * \epsilon`}, for ${tex`n \in \mathbb{N}`}. 2. We can enumerate the nodes of the tree, in a breadth-first order, since each node is an interval that corresponds to an infinitesimal interval at the limit of the tree. Regarding this second approach, even though we can enumerate this countable infinity of intervals corresponding to the nodes at finite levels of the tree before we reach the limit, each of these intervals has rational endpoints, and thus it may seem we are not actually enumerating the reals by merely enumerating these rationally-bounded intervals. These rational endpoints would all be finite sums of powers of 2 followed by an infinite tail of `0`s. But remember that the limit of an infinite sequence of these nested rationally-bounded intervals is a single real number, so it does not matter that every interval at every finite level of the binary tree of intervals has rational endpoints. At the limit of the infinite sequence of nested closed intervals, each infinitesimally small interval that corresponds to one real number is essentially no longer merely rationally bounded. In any event, each of these finite level intervals corresponds by an infinitesimal interval at the limit of the tree, so they have the same cardinality.3f:T7b5,

Binary Tree Enumerating the Intervals Breadth-First

Level

Binary Tree Enumerating the Intervals Breadth-First

#10

#11

#12

#13

#14

#15

...

${tex`\omega`}

...

#10

...

#11

...

#12

...

#13

...

#14

...

#15

...

40:T535,## The Infinite Complete Binary Tree of Digits The above argument, which starts with an infinite complete binary tree of intervals that have rational endpoints, is strikingly similar to many variations of arguments given by people attempting to show that the Reals are countably infinite by showing how an enumeration of rational numbers approaches the limit of reals. But note that those arguments assume we have an infinite complete binary tree of _digits_ rather than intervals, where each node represents a binary digit, `0` or `1`. For that tree, we can easily enumerate the countable infinity of nodes of this tree, but every node in this tree represents only a finite number of digits of a rational number, the sum of a finite number of negative powers of 2. Although the limit of this tree includes all reals between 0 and 1, which are represented by all paths through the tree, this is not the same as enumerating all the paths through the tree. Another way to look at the binary tree of digits is that every finite node can be defined to represent not just a single rational number but the set of all real numbers that have that rational number as a prefix. This is, in fact, equivalent to replacing the digit at each node with an interval, but by using intervals explicitly, we make this distinction more obvious.41:T470,### The Paradox of an Uncountable Infinity of Reals Many people have been puzzled about the countable infinity of nodes in this infinite complete binary tree when compared to the (assumed) uncountable infinity of all possible paths through the tree that correspond to the set of Reals. [Binary tree - Wikipedia](http://go/wpda/Binary_tree) describes the accepted understanding this way: > "In the infinite complete binary tree, every node has two children (and so the set of levels is countably infinite). The set of all nodes is countably infinite, but the set of all infinite paths from the root is uncountable, having the cardinality of the continuum." It is agreed that the **set of all nodes** of the infinite complete binary tree is countably infinite even though these nodes represent all the digits of all the real numbers in the interval. But the **set of all possible paths** through those same nodes is uncountable since each unique path corresponds to a real number. This contrast between a countable infinity of digits for an uncountable infinity of reals is seen by some as merely a paradox, and not a contradiction. 42:T693,Since we can now see that the set of Reals must be countable, this paradox is really a contradiction. There are several ways to see this paradox/contradiction more clearly just by examining the infinite binary tree of digits. * At every finite level of the binary tree, the number of leaf nodes at that level is exactly the same as the total number of all possible finite length paths down to that level of the tree. (For example, at level 3 there are ${tex`2^3 = 8`} leaf nodes and the same number of all possible paths ending at these nodes.) And yet, at the limit of the tree, with no more than a countable infinity of leaf nodes, somehow the number of possible paths through the tree explodes to an uncountable infinity. * If the countable infinity of nodes at the limit of the infinite binary tree of digits correspond one to one with the unique paths through the tree, then how could there be an uncountable number of paths unless there are somehow more nodes at the limit of the infinite binary tree that were missed? * If we could multiply the countable infinity of digits in each real by the uncountable infinity of the set of all reals, the product should be at least an uncountable infinity of digits. But this uncountable infinity of digits of all those reals are somehow compressed into a countable infinity of nodes in the infinite binary tree. That would suggest that there is an uncountable amount of redundancy in the Reals. 43:T54e,## Some formalism, still in the works Each node of the infinite complete binary tree of closed intervals is defined as an interval, where the endpoints of each interval are defined in terms of the endpoints of a previous interval. ${tex`\begin{aligned} \text{Node}_0 &= [0, 1] \\ \text{Node}_n &= [a_n, b_n], \text{for some } a_n, b_n \\ \text{Node}_1 &= [a_0, \frac{a_0 + b_0}{2}] = [0, \frac{1}{2}] \\ \text{Node}_2 &= [\frac{a_0 + b_0}{2}, b_0] = [\frac{1}{2}, 1] \\ &\vdots \\ \text{Node}_{n+1} &= \text{let } \begin{aligned} & && a &= a_{\lfloor n / 2 \rfloor}, \\ &&& b &= b_{\lfloor n / 2 \rfloor}, \\ &&& m &= \frac{a + b}{2} \end{aligned} & \text{in } \begin{cases} [a, m] & \text{if } n \text{ is even} \\ [m, b] & \text{if } n \text{ is odd} \\ \end{cases} \\ \end{aligned}`} The whole tree can be defined as an infinite sequence of levels, where each level is defined as a sequence of nodes. ${tex`\begin{aligned} \text{Tree } &= (\text{Level}_i)_{i=0}^{i=\infty} \\ \\ \text{Level}_0 &= (\text{Node}_0) \\ \text{Level}_1 &= (\text{Node}_1, \text{Node}_2) \\ \text{Level}_2 &= (\text{Node}_3, \text{Node}_4, \text{Node}_5, \text{Node}_6) \\ \\ \text{Level}_3 &= (\text{Node}_k)_{k=3^2 - 1}^{k=(3+1)^2 - 2} = (\text{Node}_k)_{k=7}^{k=14} \\ &\vdots \\ \text{Level}_n &= (\text{Node}_k)_{k=n^2 - 1}^{k=(n+1)^2 - 2} \\ \end{aligned} `}44:T617, The _binary expansion_ of `r` is the infinite series: ${tex`\begin{aligned} r &= \sum_{n=0}^{\infty} \frac{a_n}{2^n} \\ \text{where } & a_n \in \{0, 1\} \text{ for all } n \end{aligned} `} The _binary representation_ of a real number `r` is the sequence of 0 and 1 digits that represent the binary expansion of `r`. ${tex` \begin{aligned} r &= [a_0, a_1, a_2, ... ]_2 \end{aligned} `} A _path_ through the infinite complete binary tree of closed intervals corresponds to the sequence of digits of the binary representation of some real number `r`. This path is defined here as an infinite sequence of nodes, where each node corresponds to the left or right branch of the previous node in the sequence. First we define the two branch indices of each node to another node. ${tex`\begin{aligned} \text{Branch}_0^0 &= 1, \text{ for the left branch from node 0 to node 1} \\ \text{Branch}_0^1 &= 2, \text{ for the right branch from node 0 to node 2} \\ &\vdots \\ \text{Branch}_n^b &= \begin{cases} & {2n+1} & \text{if } b \text{ is } 0 \\ & {2n+2} & \text{if } b \text{ is } 1 \end{cases} \\ \end{aligned} `} Now we can define the infinite sequence of intervals via their nodes as computed from the binary representation of ${tex`r = [a_0, a_1, a_2, ... ]_2`}, in terms of the branch indices. ${tex` \begin{aligned} p_0 &= 0 \\ p_1 &= {\text{Branch}_{p_0}^{a_0}} \\ p_2 &= {\text{Branch}_{p_1}^{a_1}} \\ &\vdots \\ p_{k+1} &= {\text{Branch}_{p_k}^{a_k}} \\ \\ \text{Path}_r &= (\text{Node}_{p_k})_{k=0}^{k=\infty} \end{aligned} `}45:T596,An infinite sequence of nested closed intervals can be represented by the following ${tex` \begin{aligned} I_1 &= [a_1, b_1] \\ I_2 &= [a_2, b_2] \subset I_1 \\ I_3 &= [a_3, b_3] \subset I_2 \\ &\vdots \\ I_n &= [a_n, b_n] \subset I_{n-1} \end{aligned} `} where ${tex`a_n, b_n \in \mathbb{R} \text{ and } a_n \leq b_n \text{ for all } n`}. Let ${tex`I_n = [a_n, b_n]`} be an infinite sequence of nested closed intervals, with ${tex`a_n \leq b_n \text{ for all } n`}. We define the limit of this sequence to be the set ${tex`L = \bigcap_{n=0}^{\infty} I_n`}. If ${tex`L`} is nonempty, we can write ${tex`L = [a, b]`} for some real numbers ${tex`a \text{ and } b, \text{ with } a \leq b`}. In this case, we say that the sequence ${tex`I_n`} converges to the interval ${tex`[a, b]`}. By the definition of a limit, this means that for every ${tex`\epsilon > 0`}, there exists an ${tex`N`} such that for all ${tex`n > N`}, we have ${tex`b_n - a_n < \epsilon`}. We can write this as follows: ${tex` \begin{aligned} \lim_{n\to\infty} (b_n - a_n) &= 0 \\ \lim_{n\to\infty} b_n - \lim_{n\to\infty} a_n &= 0 \\ \lim_{n\to\infty} b_n &= \lim_{n\to\infty} a_n \\ \end{aligned} `} The limit of the sequence ${tex`I_n`} is then given by the following notation: ${tex` \begin{aligned} \lim_{n\to\infty} I_n &= [a, b] \\ \text{ where } a &= \lim_{n \to \infty} a_n \\ \text{ and } b &= \lim_{n\to\infty} b_n \\ a &= b \end{aligned} `} 46:T848,## An Obvious Contradiction between Countably Infinite Intervals and Uncountably Infinite Reals (This is an earlier version of the above, perhaps more readable, though less thorough. Merging with the above...) There is a clear and obvious contradiction that results by assuming the Reals are uncountable. This contradiction is otherwise independent of Cantor's diagonalization argument that the Reals are uncountable, and it similarly contradicts all other proofs of uncountability of the Reals. Many people have been puzzled about the countable infinity of nodes in an "infinite complete" binary tree when compared to the uncountable infinity of all possible paths through this binary tree that correspond to the set of Reals. The nodes of this infinite complete binary tree represent the digits of all possible real numbers. [Binary tree - Wikipedia](http://go/wpda/Binary_tree) describes the problem this way: > "In the infinite complete binary tree, every node has two children (and so the set of levels is countably infinite). The set of all nodes is countably infinite, but the set of all infinite paths from the root is uncountable, having the cardinality of the continuum." Even though it is agreed that the **set of nodes** of the infinite complete binary tree representing all digits of all numbers in the interval is countably infinite, the **set of infinite paths** through those same nodes of the binary tree that corresponds to the set of real numbers is somehow uncountable. This is seen by some as merely a paradox, rather than a contradiction. If we only think of each real number as an independent unique sequence of digits, one of the unique paths through this binary tree, with no known way to enumerate all of them, it seems plausible that there could be an uncountable number of real numbers within any interval that we might have missed between each number that we could enumerate. And then Cantor's arguments seem to more certainly determine that there will always be more missing numbers than could ever be enumerated. So this line of argument fails to show the Reals are countable. 47:Teb2,However, rather than dealing only with digits in this infinite complete binary tree, we can map each node of the tree to an interval, as we did above. (See the Binary Tree of Enumeration Intervals) For each level of the binary tree, we will have a finite length list of contiguous intervals that collectively (by union of the intervals) cover the entire range we started with, [0, 1). At level 1, we will have two intervals, [0, 1/2) and [1/2, 1), and the union of these two intervals is [0, 1). At level 2, we will have four intervals, etc. Now, armed with this binary tree of intervals, we can make a different kind of argument. Specifically, at the limit of this binary tree of intervals, we will have a countable infinity of intervals that cover the entire range, [0,1). And if we traverse any path through this binary tree of intervals, we will get a countably infinite sequence of nested intervals, and the limit of this sequence is a single real number. Now if every possible real number between 0 and 1 is represented by one unique sequence of nested intervals and we have only a countable infinity of intervals in the binary tree, then there can only be a countable infinity of real numbers. There is a significant difference between the argument based on the infinite binary tree of digits and the infinite binary tree of intervals. Each real number can be defined as an infinite sequence of digits or as an infinite sequence of nested closed intervals. It isn't obvious how to relate any one of the infinite sequences of digits representing one real number to all the other numbers, and it doesn't seem possible to enumerate all the reals at the limit of this tree. However, each node of a path through the binary tree of digits could effectively represent the set of all the real numbers that share the same prefix from the root down to that node, if we instead think about the interval of all those numbers. And that is what we are doing with the infinite binary tree of intervals. As we approach the limit of an infinite sequence of nested intervals, each interval covers a smaller and smaller range, even though the set of real numbers in that range is the same size as the set of all Reals, and moreover, the union of all the intervals at any level in the binary tree of intervals necessarily includes all reals in the entire range, [0, 1), so none will be excluded. Here are two claims that we should understand and accept: 1. At the limit of the infinite binary tree of intervals subdividing the interval [0, 1), there can only be a countable infinity of contiguous closed (or left-closed, right-open) intervals. This countable infinity of intervals includes every real number in the interval [0, 1). 2. The limit of every unique infinite sequence of nested left-closed, right-open intervals is one unique real number. Then together, these two claims mean there can be no more than a countable infinity of real numbers corresponding to those countable intervals. It is, of course, contradictory to claim that the Reals are both countable and uncountable. If the Reals are nevertheless uncountable, then there must be something wrong with the above argument. Could it be true that the limit of an infinite sequence of nested closed intervals is not a single real number? Perhaps the limit must either be undefined or a set with the same cardinality as the continuum. Could it be that the nodes of an infinite complete binary tree are not countable? Could it be that the limit of the subdivision of intervals is not a countable set, or that the infinitesimally small intervals must contain more than one number? If none of those alternatives make sense, then we have to consider whether the Reals must be countable after all.48:T8b9, Then, the limit of every path through the binary tree of intervals will approach a single real number, according to the ["Nested intervals](http://go/wpda/Nested_intervals)" theorem. Actually, our intervals are all half-open, closed on the left and open on the right, but the same argument applies here, so none of these sequences will result in the empty set at the limit. See [Nested sequence of half open intervals with non-empty intersection](https://math.stackexchange.com/questions/3015727/nested-sequence-of-half-open-intervals-with-non-empty-intersection). It should also be clear that, if we could enumerate every path through this binary tree, and thus every sequence of nested intervals, this would be equivalent to an enumeration of the Reals, one for each real number that is the limit of each unique sequence of nested intervals. More about that next. The infinite complete binary tree of intervals also provides an enumeration of the Reals, since there is a bijection from the Reals to this countable infinity of intervals that cover the entire range of numbers between 0 and 1, and we can enumerate the countable infinity of intervals just as we enumerated the subdivision of enumerations described above. 49:T1295,function makeIntervalTreeVegaSpec(data, options = {}) { options = { title: "", width: 500, height: 300, colorScheme: "turbo", hideLabels: false, linkShape: "diagonal", ...options }; // Node labels const nodeLabels = options.hideLabels ? [] : [ { type: "text", from: { data: "tree" }, encode: { enter: { text: { signal: "datum.label" }, font: { value: "monospace" }, fontSize: { value: 11 }, baseline: { value: "middle" } }, update: { x: { field: "x" }, y: { field: "y" }, dx: { signal: "datum.children ? -5 : 7" }, align: { signal: "datum.children ? 'right' : 'left'" }, dy: { signal: "datum.children ? -10 : 0" }, fontWeight: [ { test: "datum.index === active", value: "bolder" }, { value: "normal" } ] } } } ]; return { $schema: "https://vega.github.io/schema/vega/v5.json", title: options.title, width: options.width, height: options.height, padding: 5, signals: [ { name: "active", value: null, on: [ { events: "mouseover", update: "datum.index" }, { events: "mouseover[!event.item]", update: "null" } ] } ], data: [ { name: "tree", values: data, transform: [ { type: "stratify", key: "id", parentKey: "parent" }, { type: "tree", size: [ { signal: "height" }, { signal: `width - (${options.hideLabels} ? 0 : 100)` } ], method: "cluster", separation: false, as: ["y", "x", "depth", "children"] } ] }, { name: "links", source: "tree", transform: [ { type: "treelinks" }, { type: "linkpath", orient: "horizontal", shape: options.linkShape }, { as: "index", type: "formula", expr: "datum.target.index" } ] } ], scales: [ { name: "color", type: "linear", range: { scheme: options.colorScheme }, domain: { data: "tree", field: "index" }, zero: true } ], marks: [ // Nodes { type: "symbol", from: { data: "tree" }, encode: { enter: { size: { value: 150 }, stroke: { value: "#fff" } }, update: { x: { field: "x" }, y: { field: "y" }, size: [ { test: "datum.index === active", value: 160 }, { value: 100 } ], fill: [{ scale: "color", field: "index" }] } } }, ...nodeLabels, // Interval marks { type: "text", from: { data: "tree" }, encode: { enter: { text: { signal: "datum.startOfInterval ? '┏━━━━━━━━━━━━━━━━━━' : datum.endOfInterval ? '┗━━━━━━━━━━━━━━━━━━' : ''" // ┓┛ }, // Also: ┓ ┛ fontSize: { value: 10 }, baseline: { value: "middle" } }, update: { x: { field: "x" }, y: { field: "y" }, dy: { signal: "datum.startOfInterval ? -5 : 6" }, opacity: { value: 1 } } } }, // Links between adjacent nodes { type: "path", from: { data: "links" }, encode: { update: { path: { field: "path" }, strokeWidth: [ { test: "datum.index === active", value: 4 }, { value: 2 } ], stroke: [{ scale: "color", field: "index" }] } } } // Label for first node of Num // { // "type": "text", // "from": {"data": "tree"}, // "encode": { // "enter": { // "text": {"signal": "datum.firstNumLabel"}, // "fontSize": {"value": 11}, // "zindex": {"value": 1}, // "baseline": {"value": "middle"}, // "align": {"value": "right"}, // }, // "update": { // "x": {"field": "x"}, // "y": {"field": "y"}, // "dx": {"value": -10}, // "opacity": {"value": 1} // } // } // }, ] }; }4a:T502,

Binary Tree of Subdivision Enumerations

Level	Binary Tree of Subdivision Enumerations
0	0. ...
1	.0...								.1...
2	.00...				.01...				.10...				.11...
3	.000...		.001...		.010...		.011...		.100...		.101...		.110...		.111...
4	.0000...	.0001...	.0010...	.0011...	.0100...	.0101...	.0110...	.0111...	.1000...	.1001...	.1010...	.1011...	.1100...	.1101...	.1110...	.1111...
...	...

4b:T58f,

Binary Tree of Enumeration Intervals

Level	Binary Tree of Enumeration Intervals
0	[0, 1)
1	[.0, .1)								[.1, 1)
2	[.00, .01)				[.01, .10)				[.10, .11)				[.11, 1)
3	[.000, .001)		[.001, .010)		[.010, .011)		[.011, .100)		[.100, .101)		[.101, .110)		[.110, .111)		[.111, 1)
4	[.0000, .0001)	[.0001, .0010)	[.0010, .0010)	[.0011, .0100)	[.0100, .0101)	[.0101, .0110)	[.0110, .0111)	[.0111, .1000)	[.1000, .1001)	[.1001, .1010)	[.1010, .1011)	[.1011, .1100)	[.1100, .1101)	[.1101, .1110)	[.1110, .1111)	[.1111, 1)
...	...

4c:T1081,## An Abbreviated History of this Argument Most people who learn about the argument presented here and the associated arguments about the countability of the Reals and the refutation of Cantor's diagonalization seem to be primarily if not solely interested in the refutation argument. I for one didn't try to seriously find a refutation for Cantor's arguments, and didn't even imagine it was possible, until I could first intuitively understand how the Reals are countable independent of Cantor's arguments and eventually prove at least to myself that the Reals must be countable. I suspect a similar approach might help a few others who are more like myself. You'd have to be open to the possibility that the Reals could be countable, so it probably won't help people who are firm believers in the correctness of Cantor's arguments, so if that includes you, then you are probably more interested in whether the refutation is valid, and you may be assuming it can't possibly be valid. Once I could see how the Reals can be shown to be countable, I went back to Cantor's arguments to try to figure out what could be going wrong there. It is admittedly a tough puzzle, and it didn't help much to look into the many attempts by other people to refute the diagonalization argument specifically, since most are easily shot down. But it did help foment ideas, since each attempt seemed to have a kernel of a good idea, though framed in a seriously flawed argument, with a couple rare exceptions. I spent most of the last couple years trying to find a valid refutation, and was feeling rather frustrated by all the dead ends I encountered. But that didn't dissuade me from accepting the proof of countability of the Reals, though not because I was just stubbornly believing it, but because it appears valid on its own. One possible outcome of all this is more of a stalemate. If the Reals appear to be both countable and uncountable by two separate proofs, both appearing to be valid, we wouldn't be able to decide whether the Reals are countable or uncountable. It would not be the first time such a thing has happened in math, that we are left with an undecidable set of alternatives, though usually we are left with proofs of unprovability rather than conflicting proofs. And if it turned out to not be possible to refute Cantor's arguments, then people would have a hard time considering the possibility that there might also be a valid proof that the Reals are countable. But even assuming I could come up with a valid refutation, that would nevertheless leave a few questions open. What about his other arguments, the nested closed intervals, and the multi-dimensional generalization of that, which are at least closely related to the diagonalization argument though not identical? Will refuting the diagonalization argument be enough to also refute the others, or is something more going on there? Are there any other ways to prove the Reals are uncountable that don't rely on the diagonalization argument, directly or indirectly? I suspect not, though discussion I have found on mathexchange doesn't make the answer completely clear. And assuming valid refutations could be found for all known proofs of uncountability, we are left with not knowing whether there might still be another way to prove uncountability. Given all that, and the fact that the proof of the countability of the Reals is not all that difficult to understand, if you take it seriously enough to go through the details, it seemed like a good approach to start with that first. So I cleaned up the demonstration and proof of countability, as best I could, but I still did not want to make it public without dealing with Cantor's arguments once again. Only recently did I finally find a valid refutation of diagonalization based on an earlier idea, which then led to the simpler proof of countability documented here. This document was the last article in the series, so far, and it makes sense to read it in the same order. However, this document and the refutation of diagonalization can stand on their own, since there is no dependence on proving the countability of the Reals in different ways and the refutation of diagonalization.4d:T168a,// Copyright 2021 Observable, Inc. // Released under the ISC license. // https://observablehq.com/@d3/icicle // Adding: // value vs size. // showValue option // Hacked to bits. function Icicle( data, { // data is either tabular (array of objects) or hierarchy (nested objects) path, // as an alternative to id and parentId, returns an array identifier, imputing internal nodes id = Array.isArray(data) ? (d) => d.id : null, // if tabular data, given a d in data, returns a unique identifier (string) parentId = Array.isArray(data) ? (d) => d.parentId : null, // if tabular data, given a node d, returns its parent's identifier children, // if hierarchical data, given a d in data, returns its children format = ",", // format specifier string or function for values value, // given a node d, returns a quantitative value (for a value encoding; null for count) size, // given a node d, return the quantitative value for the area encoding. showValue = true, sort = (a, b) => d3.descending(a.value, b.value), // how to sort nodes prior to layout label, // given a node d, returns the name to display on the rectangle title, // given a node d, returns its hover text link, // given a node d, its link (if any) linkTarget = "_blank", // the target attribute for links (if any) width = 640, // outer width, in pixels height = 400, // outer height, in pixels margin = 0, // shorthand for margins marginTop = margin, // top margin, in pixels marginRight = margin, // right margin, in pixels marginBottom = margin, // bottom margin, in pixels marginLeft = margin, // left margin, in pixels padding = 1, // cell padding, in pixels round = false, // whether to round to exact pixels color = d3.interpolateRainbow, // color scheme, if any fill = "#ccc", // fill for node rects (if no color encoding) fillOpacity = 0.6 // fill opacity for node rects } = {} ) { // If id and parentId options are specified, or the path option, use d3.stratify // to convert tabular data to a hierarchy; otherwise we assume that the data is // specified as an object {children} with nested objects (a.k.a. the "flare.json" // format), and use d3.hierarchy. const root = path != null ? d3.stratify().path(path)(data) : id != null || parentId != null ? d3.stratify().id(id).parentId(parentId)(data) : d3.hierarchy(data, children); // Compute the default values of internal nodes by aggregating from the leaves. // value = // value ? value : // (d) => d.data.dvalue; // was: root.sum((d) => Math.max(0, value(d))); // const dvalues = []; // Compute the sizes of internal nodes by aggregating from the leaves. size == null ? root.count() : root.sum((d) => { return Math.max(0, size(d)); }); // Compute formats. if (typeof format !== "function") format = d3.format(format); // Sort the leaves (typically by descending value for a pleasing layout). if (sort != null) root.sort(sort); // Compute the partition layout. Note that x and y are swapped! d3 .partition() .size([height - marginTop - marginBottom, width - marginLeft - marginRight]) .padding(padding) .round(round)(root); // Construct a color scale. // if (color != null) { // color = d3 // .scaleSequential([0, root.children.length - 1], color) // .unknown(fill); // root.children.forEach((child, i) => (child.index = i)); // } if (color != null) { // color = d3.scaleSequential([0, 1], color); // .unknown(fill); // root.children.forEach((child, i) => (child.index = child.value)); } const svg = d3 .create("svg") .attr("viewBox", [-marginLeft, -marginTop, width, height]) .attr("width", width) .attr("height", height) .attr("style", "max-width: 100%; height: auto; height: intrinsic;") .attr("font-family", "sans-serif") .attr("font-size", 10); const cell = svg .selectAll("a") .data(root.descendants()) .join("a") .attr("xlink:href", link == null ? null : (d) => link(d.data, d)) .attr("target", link == null ? null : linkTarget) .attr("transform", (d) => { return `translate(${d.y0},${d.x0})`; }); const defs = svg.append("defs"); var gradient = defs .append("linearGradient") .attr("id", "svgGradient") .attr("gradientTransform", "rotate(90)"); gradient .append("stop") .attr("class", "start") .attr("offset", "0%") .attr("stop-color", "black") .attr("stop-opacity", 1); gradient .append("stop") .attr("class", "end") .attr("offset", "100%") .attr("stop-color", "white") .attr("stop-opacity", 1); // const colors = []; const colorFill = color ? (d) => { // dvalues.push(d.data.dvalue); // db("dvalues", dvalues); const thisColor = color(d.data.dvalue); // colors.push(thisColor); // db("colors", colors); return thisColor; } // was: (d) => color(d.ancestors().reverse()[1]?.index) : fill; cell .append("rect") .attr("width", (d) => d.y1 - d.y0) .attr("height", (d) => d.x1 - d.x0) .attr("fill", colorFill) .attr("fill-opacity", fillOpacity); const text = cell .filter((d) => d.x1 - d.x0 > 10) .append("text") .attr("x", 4) .attr("y", (d) => Math.min(9, (d.x1 - d.x0) / 2)) .attr("dy", "0.32em"); if (label != null) text.append("tspan").text((d) => label(d.data, d)); if (showValue) { text .append("tspan") .attr("fill-opacity", 0.7) .attr("dx", label == null ? null : 3) .text((d) => format(d.value)); } if (title != null) cell.append("title").text((d) => title(d.data, d)); return svg.node(); }4e:[{"id":"44957f0cd47269fe13ac26db5f5cd1c268dd3392e1300b63482343defd00cf31aea1a20dd20a0326fc995129b82243a1190f0641fb8e00b7709c4af7d838b794","href":"https://static.observableusercontent.com/files/44957f0cd47269fe13ac26db5f5cd1c268dd3392e1300b63482343defd00cf31aea1a20dd20a0326fc995129b82243a1190f0641fb8e00b7709c4af7d838b794","name":"Nested Closed Intervals.jpg","type":"image/jpeg","lastModified":1675982223569.096,"size":21744},{"id":"d94cb74bcf0f84d3e2cc0d8a1c87c86453129df55d87f117677a361802ce25955d22da3cbbda92d64b80ac1b4550db8f17d6921584fb44645c4920d3b4b6bfa8","href":"https://static.observableusercontent.com/files/d94cb74bcf0f84d3e2cc0d8a1c87c86453129df55d87f117677a361802ce25955d22da3cbbda92d64b80ac1b4550db8f17d6921584fb44645c4920d3b4b6bfa8","name":"Nested Closed Intervals(1).jpg","type":"image/jpeg","lastModified":1675982406868.869,"size":13314}] 32:{"id":"6ffbd4ea38128f82","slug":"infinite-binary-tree-of-intervals","title":"Infinite Binary Tree of Intervals","thumbnail":"1dc89e203be726a2d432c18e443ba0dbca7b2fa1b3d0ef88bb5560b173483735","access_level":"public","create_time":"$D2023-01-22T17:57:07.565Z","update_time":"$D2024-03-04T18:39:02.057Z","view_time":null,"first_public_time":"$D2023-01-22T17:57:07.565Z","has_unpublished_edits":null,"fork":{"id":"2555290b866cbe32","slug":"refutation-of-cantors-diagonalization","title":"Refutation of Cantor's Diagonalization","owner":{"id":"88bca6b25e968fae","login":"dlaliberte","name":"Daniel LaLiberte"}},"stars":3,"starred":false,"owner":{"type":"team","id":"88bca6b25e968fae","login":"dlaliberte","name":"Daniel LaLiberte","avatar_url":"https://avatars-next.observableusercontent.com/e5ca1f0f640d7d3579ea69f7316220ebcec267322399e2773f31b91bc2790b15","tier":"starter_2024"},"version":4028,"publish_version":null,"role":null,"authored":false,"authors":[{"type":"individual","id":"b887ef310da1b17a","login":"dlaliberte","name":"Daniel LaLiberte","avatar_url":"https://avatars-next.observableusercontent.com/e5ca1f0f640d7d3579ea69f7316220ebcec267322399e2773f31b91bc2790b15","tier":null}],"members":[{"type":"individual","id":"b887ef310da1b17a","login":"dlaliberte","name":"Daniel LaLiberte","avatar_url":"https://avatars-next.observableusercontent.com/e5ca1f0f640d7d3579ea69f7316220ebcec267322399e2773f31b91bc2790b15","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"lapsed":null,"subscribed":null,"forks":4,"collection":null,"type":"notebook","body":{"title":"Infinite Binary Tree of Intervals","cells":[{"id":0,"value":"# Infinite Binary Tree of Intervals\n\nBy Merril Jordahl, Jena Jordahl, Daniel LaLiberte (daniel.laliberte@gmail.com)","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":775,"value":"## Abstract\n\nWe construct an infinite complete binary tree of half-open intervals to show that the countable infinity of infinitesimal-width intervals at the limit covers the entire interval `[0, 1)`, with no more than one real number in each interval. Thus, the cardinality of the Reals is the same as that of the Naturals.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":767,"value":"### Related documents\n\nIf you are interested in this subject, please also read the earlier notebooks:\n\n- [Number Objects](https://observablehq.com/@dlaliberte/number-objects)\n- [Computable Real Numbers](https://observablehq.com/@dlaliberte/computable-real-numbers)\n- [Countably Infinite Random Real Numbers](http://observablehq.com/@dlaliberte/countably-infinite-random-real-numbers)\n- [Refutation of Cantor's Diagonalization](https://observablehq.com/@dlaliberte/refutation-of-cantors-diagonalization)\n\nSeveral posts have been created on a WordPress blog about the same subject: \"[The Rational Continuum](https://rationalcontinuum.wordpress.com/)\".\n- [Refutation of Cantor’s Diagonal Argument via the Infinite Tree of Intervals](https://rationalcontinuum.wordpress.com/2023/06/30/refutation-of-cantors-diagonal-argument-via-infinite-tree-of-intervals/)\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3196,"value":"$34","pinned":false,"hidden":false,"mode":"html","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":771,"value":"toc(\"h2, h3, h4, h5, h6\")","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2063,"value":"## Infinite Complete Binary Trees\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3108,"value":"A binary tree is a way of arranging data in a tree-like structure. Every binary tree we will discuss in this document is an _infinite **complete** binary tree_, which means that _every_ node has two child nodes. While the structure of the binary trees will be the same in each example, what each node represents will vary from one example to the next. \n\nTypically, each node is associated with a binary digit, either `0` or `1`. If we start at the root node and follow the left or right branch of each node, we can create an infinitely long sequence of digits that corresponds to some real number. Therefore, this binary tree of digits represents all possible combinations of an infinite number of binary digits, one combination for each path through the tree.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3096,"value":"

\n Infinite complete binary tree of digits (from: [Quantum Random Self-Modifiable Computation](https://www.researchgate.net/figure/Infinite-Binary-Tree-A-Graphical-Representation-of-0-1-N_fig2_326044205))\n
\n **Note:** This tree of digits is only shown to highlight a distinction between this and what we are doing.\n

","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3311,"value":"We can easily enumerate some set of numbers represented by this infinite binary of digits by traversing the tree in various ways. But if we only visit each node at a finite level of the tree, each node would correspond to only a finite sequence of digits from the root down to that node. For example, the node at level 0 represents the number `0`. The two nodes at level 1 represent `0.0` (also `0`) and `0.1` (which is binary for `1/2`). The red path through the binary tree above represents the number `0.0110`. \n\nEvery real number between `0` and `1` corresponds one-to-one with some path through the binary tree, but to enumerate all those real numbers, we would need to somehow visit each of the _infinitely long_ sequences of digits in some order. This is the problem we are addressing here, but rather than using a binary tree of digits, we will use a binary tree of _intervals_.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3859,"value":"### Nodes along Each Path versus Nodes on the Same Level\n\nThere are two ways to view an infinite binary tree, and both perspectives are essential for understanding the argument presented in this document:\n\n* As a _set of paths_, where each path is an infinitely long sequence of nodes. The focus is on the set of all paths through sequences of nodes, where each node is connected to two child nodes. This view corresponds to thinking about traversing the tree in depth-first order.\n* As a _sequence of levels_, where each level is a set of all neighboring nodes at the same depth. This view corresponds to thinking about traversing the tree in breadth-first order.\n\nThe same binary tree structure will be used to access nodes via both paths and levels.\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3881,"value":"## An Infinite Binary Tree of Closed Intervals Results in a Contradiction","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":1871,"value":"Instead of a binary tree of _digits_, we will first construct a binary tree of _closed intervals_ where each node is associated not with a digit but with a closed interval. At level 0, the root node corresponds to the closed interval of all real numbers between `0` and `1` including `0` and `1`, notated as `[0, 1]`. At level 1, there are two subintervals, `[0, 1/2]` and `[1/2, 1]`, which have `1/2` as a shared endpoint. The union of these two subintervals is the whole interval, `[0, 1]`, and the intersection is the set, ${tex`\\{1/2\\}`}, containing only this one shared endpoint.\n\nFor each subsequent level of the binary tree, we will subdivide every interval of the previous level into two closed subintervals with a shared endpoint half-way between the endpoints of the previous interval. The union of all the intervals on each level is the same as the whole interval, `[0, 1]`, and the intersection is the set of all the shared endpoints. \n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3168,"value":"\nThe following table shows the first few levels of this infinite binary tree of closed intervals, with endpoints represented in binary. The last row represents the limit, but there is a problem which is explained below.\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2122,"value":"$35","pinned":false,"hidden":false,"mode":"html","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3171,"value":"\nAn important point to emphasize is that each interval in this binary tree of intervals corresponds not to one digit, but to **all numbers in the interval**. At level 0, the interval `[0, 1]` includes all real numbers between 0 and 1; these numbers are represented in binary by \"`0.`\" followed by an infinite string of every combination of `0`s and `1`s. At level 1, the two intervals together include every number in the interval `[0, 1]`, but now they are subdivided into two intervals. The first interval, `[0, 1/2]` contains all the numbers between `0` and `1/2`, and the second interval, `[1/2, 1]`, contains all the numbers between `1/2` and `1`. These numbers are represented in binary with \"`0.0`\" and \"`0.1`\", respectively, followed by an infinite string of every combination of `0`s and `1`s.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3079,"value":"#### An Infinite Sequence of Nested Closed Intervals\n\nBy traversing a depth-first path through the infinite binary tree of closed intervals, starting from the root node and choosing left or right subintervals at subsequent levels, we can construct an infinite sequence of nested closed intervals. Here is a diagram representing an infinite sequence of nested closed intervals that happens to correspond to the red path in the binary tree of digits shown above.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3122,"value":"nestedClosedIntervals = FileAttachment(\"Nested Closed Intervals(1).jpg\").image()","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":3326,"value":"\nBy the [\"Nested intervals](http://go/wpda/Nested_intervals)\" theorem, the limit of such an infinite sequence of nested closed non-empty intervals is one real number. Or rather, the limit is a singleton set containing that number, which can be equivalently represented by an **interval in which both endpoints have the same value**. Such an interval at the limit would be `[r, r]` for some real number, `r`. This idea of constructing a sequence of nested closed intervals that narrow in on one real number is closely related to one way that all real numbers are defined, by the way (see [Cauchy sequence](http://go/wpda/Cauchy_sequence) for the details).\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3864,"value":"$36","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3216,"value":"### A Contradiction between Paths Versus Levels\n\nEvery path through the infinite binary tree of closed intervals, from the root down toward the limit, is an infinite sequence of nested closed non-empty intervals which, at the limit, is one real number. Also, at every level of the binary tree, every interval is constructed the same way by subdividing an interval in the previous level into two intervals that share an endpoint. Consequently, there are two conflicting constraints which result in a contradiction.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2596,"value":"\n1. Each interval at the limit contains only one real number, so **at the limit, both endpoints of each interval must be the same number**.\n2. Every pair of neighboring intervals must share an endpoint, and even **at the limit, each pair of neighboring intervals must share an endpoint number**.\n\nBut these two constraints together would mean **all the intervals at the limit must be the same interval** (shown as the ${tex`[r, r]`} intervals in the middle of the last row of the table above). If that is not enough of a problem, all the intervals at the limit must be different from the first and last intervals, ${tex`[0, 0]`} and ${tex`[1, 1]`}, so clearly, there is a contradiction.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2438,"value":"$37","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3144,"value":"### Two Conflicting Constraints\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2620,"value":"\nLet's first revisit the constraint regarding the paths through the tree. Each path is an infinite sequence of nested closed intervals starting at the root level and choosing either the left or right subinterval on each subsequent level. We can conclude the following points:\n\n1. Every interval in the infinite sequence of closed intervals is a strict non-empty subset of the previous interval.\n3. By the [\"Nested intervals](http://go/wpda/Nested_intervals)\" theorem, the limit of any such infinite sequence of nested closed intervals is a singleton set of one real number, which is represented by an **interval in which both endpoints have the same value**.\n\nWhen presented on its own, this seems self-consistent, as it certainly is possible to have the same number at both endpoints of an interval, e.g. `[r, r]`. And so at the limit of the infinite binary tree of closed intervals, it is seems possible that both endpoints of each interval could be the same number. ","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2168,"value":"But now let's reexamine the constraint on all the intervals of every level of the tree. This tree is defined as a sequence of levels where each level specifies a finite number of closed intervals derived from the intervals in the previous level. We subdivide each interval into two subintervals such that they have a shared endpoint. We can conclude the following points:\n\n1. Each finite level of the binary tree is defined by a set of closed intervals such that the union of the intervals covers the whole closed interval, `[0, 1]`, so this should also be true at the limit.\n3. On every finite level of the binary tree, **every pair of neighboring intervals shares an endpoint** which is one real number, and this should also be true at the limit. Two neighboring intervals would be `[r, s]` and `[s, t]`, where `r` and `t` are different numbers.\n\nThese points on their own also seem self-consistent.\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3937,"value":"One important point should be emphasized. Every closed interval on every _finite_ level of the binary tree has different endpoints, ${tex`[r, s]`}, such that there is another real number halfway between them, ${tex`(r + s) / 2`}. But at the limit, this is no longer true, since it is not possible for an interval at the limit to contain more than one real number, since if it did, we would not yet be at the limit. ","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2622,"value":"So we have two constraints on the intervals in the infinite binary tree of closed intervals that are consistent with each other at every _finite_ level of the tree, but both constraints cannot be satisfied at the limit.\n\n1. Every interval at the limit has endpoints that are the same number.\n2. Every pair of neighboring intervals at the limit has a shared endpoint number.\n\nIf both of these constraints are true, then all intervals would have the same number for all endpoints, but that is a contradiction since `0` and `1` are two different numbers that are in the original interval.\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3338,"value":"\nOne way we might resolve these conflicting constraints is that we could change one of them to avoid the conflict.\n\n1. Maybe every interval at the limit could have endpoints that are different numbers.\n2. Maybe every pair of neighboring intervals at the limit cannot share the same endpoint number.\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3155,"value":"\nWhile every closed interval at every finite level of this binary tree has different endpoints, but every interval at the limit has endpoints that must be the same, maybe the contradiction involves the definition of limits. After all, limits were explicitly created to avoid dealing with the infinitesimals that had been used informally in Calculus. So maybe we can't ignore the infinitesimals and thus exclude them from the Reals without creating this kind of contradiction. Maybe the Reals are uncountable only because we have neglected to count the infinitesimals.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2121,"value":"## Infinite Complete Binary Tree of Half-Open Intervals Avoids the Contradiction\n\nWe can begin to resolve this contradiction by finding a way to avoid it. Rather than associate each node with a _closed_ interval, we can use _**half-open**_ intervals, specifically left-closed and right-open, also referred to as closed-open intervals. \n\n\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3941,"value":"$38","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3944,"value":"The following table shows the first few levels of this infinite binary tree of half-open intervals, with the last row representing the limit. You'll notice that we use ${tex `\\epsilon`} in the endpoint numbers at the limit. This is explained here and in subsequent sections.\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":1873,"value":"$39","pinned":false,"hidden":false,"mode":"html","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2185,"value":"$3a","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2467,"value":"$3b","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2055,"value":"## The Reals Must be Countable\n\nThe following two points show that the set of Reals must be countable. (This is a restatement of the above argument.)","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":1869,"value":"$3c","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":1905,"value":"## Closed Intervals with Infinitesimal Width Also Avoids the Contradiction\n\nBack to the binary tree of **closed** intervals, we can avoid the contradiction another way if we decide that the limit of each infinite sequence of nested closed intervals is not simply an interval ${tex`[r, r]`}, for some real `r`, having width `0`, but an interval with an infinitesimal width, ${tex`\\epsilon`}. So each interval at the limit of each path would be ${tex`[r, r + \\epsilon]`}, for some real `r`. This way, at the limit of the binary tree of closed intervals, we would have infinitesimally small intervals with the same endpoints as for the binary tree of half-open intervals.\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3413,"value":"But note that each closed interval ${tex`[r, r + \\epsilon]`} has two _different_ real numbers as endpoints, ${tex`r`} and ${tex`r + \\epsilon`}, but fortunately, there is no real number between them. That is, any number between ${tex`r`} and ${tex`r + \\epsilon`} must be less than ${tex`\\epsilon`} away from either number, so it must not be a real number.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2459,"value":"\nThe union of the countably infinite, infinitesimal-width closed intervals would be the closed interval, `[0, 1]`, and the intersection would be the set of all the endpoints of these intervals, which is all real numbers between `0` and `1` except for the leftmost and rightmost numbers `0` and `1`. So this intersection would seem to be equivalent to the open interval `(0, 1)`, if we only consider the real numbers rather than the continuum of infinitesimals between the real numbers.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2455,"value":"## Infinitesimals All the Way Down\n\nWe can construct another infinite complete binary tree starting with each infinitesimal interval, as follows. For each infinitesimal interval ${tex`[r, r + \\epsilon)`}, we repeatedly subdivide it into smaller infinitesimals. At level 1, we will subdivide the infinitesimal interval ${tex`[r, r + \\epsilon)`} into two intervals, ${tex`[r, r + \\epsilon/2)`} and ${tex`[r + \\epsilon/2, r + \\epsilon)`}, and this subdivision process can be repeated another countable infinity of times. At the limit of this iteration, each interval would have a width of an infinitesimal of an infinitesimal, ${tex`\\epsilon * \\epsilon = \\epsilon^2`}. The total number of these intervals between `0` and `1` would be ${tex`\\omega * \\omega = \\omega^2`}. So again, the total width of these intervals is ${tex`\\epsilon^2 * \\omega^2 = 1`}. \n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2959,"value":"$3d","pinned":false,"hidden":false,"mode":"html","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3048,"value":"\nThis process can be repeated again to get ${tex`\\omega^3`} intervals of width ${tex`\\epsilon^3`}. And again and again, resulting in ${tex`\\omega^\\omega`} intervals of width ${tex`\\epsilon^\\omega`}, which is still a countable set. And then we can do all of that again and again forever, with ever smaller and smaller infinitesimals, to get ${tex`\\omega^{\\omega^\\omega}`} intervals of width ${tex`\\epsilon^{\\omega^\\omega}`}, which is also countable. Etc, etc, etc...\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":1444,"value":"$3e","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2687,"value":"$3f","pinned":false,"hidden":false,"mode":"html","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2323,"value":"### Enumerating the Reals Directly\n\nFor those still doubting that this enumeration of rationally bounded intervals is sufficient for enumerating the Reals, we can also enumerate the Reals more directly, and we do that in the \"Breadth-first Enumeration of Reals\" (see [Countably Infinite Random Real Numbers](http://observablehq.com/@dlaliberte/countably-infinite-random-real-numbers)). If you now have sufficient doubts that the Reals are uncountable, it should be easier to understand the \"Breadth-first Enumeration of the Reals\" to see how it is actually possible to enumerate the Reals directly. \n\nIt should also be easier to comprehend how Cantor's diagonalization argument and his Nested Closed Intervals arguments must be flawed.\nOther than merely claiming that those arguments must be flawed, given this proof that the Reals are countable, we should find it easier to understand the nature of the flaw in Cantor's arguments, and exactly what went wrong with those arguments.\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2414,"value":"$40","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2672,"value":"In the following visualization of a binary tree, you can see every combination of digits is generated. Also, every node in the tree corresponds to the creation of a single number which starts with a prefix of digits defined by the path from the root down to that node. In the enumeration table, you can see that every number, once it has been created, is followed by an infinite sequence of `0`s.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2425,"value":"rationals = generateAllNumbersBreadthFirst(\n Math.pow(2, 1 + infiniteBinaryTreeOfDigitsOptions.depth),\n infiniteBinaryTreeOfDigitsOptions.random\n)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2670,"value":"showEnumerationTable(rationals)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2420,"value":"viewof infiniteBinaryTreeOfDigitsOptions = form(html`\n`)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2409,"value":"vlembed(\n makeTreeVegaSpec(rationals.tree, {\n title: `Infinite Binary Tree of Digits (to depth ${\n infiniteBinaryTreeOfDigitsOptions.depth + 1\n })`,\n width: 600 + infiniteBinaryTreeOfDigitsOptions.depth * 10,\n height: Math.max(\n 300,\n 50 +\n Math.min(\n 2000,\n Math.pow(2, infiniteBinaryTreeOfDigitsOptions.depth) * 18\n )\n ),\n hideLabels: infiniteBinaryTreeOfDigitsOptions.depth > 7\n })\n)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2326,"value":"$41","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2510,"value":"$42","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2329,"value":"### Intervals Versus Digits\n\nThe two arguments which start with an infinite binary tree of either intervals or digits have a significant difference. Whereas both trees have a countable infinity of nodes, there are gaps between the paths in the binary tree of digits at every level and at the limit. The presence of these gaps might seem to suggest there could be more numbers between each number in the tree, but that doesn't actually make sense because it should be clear that no nodes were missed. Still, these gaps at the limit turn out to correspond to something \"real\" that we have been ignoring, namely the infinitesimals.\n\nWhether each node of the binary tree represents just a single digit or an interval makes a difference when we are trying to determine what happens at the limit of the tree. There could be a difference in how we conceptualize individual real numbers which correspond to each path through the tree versus the continuum of all possible numbers in the interval `[0, 1)`.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3054,"value":"\nAt the limit of the infinite binary tree of intervals, we can enumerate the countably infinite, infinitesimally small intervals that cover all possible real numbers in the interval `[0, 1)`, so we know that there are no gaps between intervals that might contain an uncountable infinity of Reals that were somehow missed. \n\nSince each infinitesimally small interval contains at most one real number, what could be in the remainder of the interval? Any other number in the interval could only be infinitesimal numbers, which are smaller than any real number.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3060,"value":"\nHow do we know that the countably infinite, infinitesimally small intervals at the limit of the binary tree of intervals is the same as the infinitesimally small intervals at the limit of every countably infinite sequence of nested intervals? That is easy to affirm here since we used the same binary tree of intervals for both.\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3418,"value":"$43","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3659,"value":"$44","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":3755,"value":"$45","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":2044,"value":"---\n\n---\n\n## -------------------------- Remaining sections (Originally from the Refutation of Cantor's Diagonalization) might not be part of final document\n\n---\n\n---","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":1629,"value":"$46","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":1960,"value":"$47","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":1456,"value":"$48","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":907,"value":"mutable nRandomDigits = []","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":905,"value":"function generateNRandomDigits(n) {\n // Slice off extras\n if (nRandomDigits.length > n) {\n nRandomDigits.splice(n);\n }\n // Push on new digits.\n while (nRandomDigits.length < n) {\n nRandomDigits.push(Math.random() < 0.5 ? \"0\" : \"1\");\n // db(\"nd\", nRandomDigits);\n }\n return nRandomDigits;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2101,"value":"$49","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1517,"value":"$4a","pinned":false,"hidden":false,"mode":"html","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":1727,"value":"$4b","pinned":false,"hidden":false,"mode":"html","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":1287,"value":"$4c","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":502,"value":"import { toc } from \"@nebrius/indented-toc\"","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":329,"value":"import { Table } from \"@observablehq/table\"","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":487,"value":"import { form } from \"@mbostock/form-input\"","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":498,"value":"vlembed = require(\"vega-embed\")","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":500,"value":"import {\n Real,\n Rational,\n Zero,\n One,\n BinaryTreeNode,\n makeTreeVegaSpec,\n showEnumerationTable,\n digitsToNumber\n} from \"@dlaliberte/number-objects\"","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":474,"value":"import {generateAllNumbersBreadthFirst} from \"@dlaliberte/countably-infinite-random-real-numbers\"","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":912,"value":"import { button } from \"@bartok32/diy-inputs\"","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1009,"value":"import { Debug } from \"@trebor/debug-tool\"","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1013,"value":"// viewof db = Debug();","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2745,"value":"function genBinaryChildren(depth = 5, low = 0, high = 1) {\n const mid = low + (high - low) / 2;\n if (depth == 0) {\n return [];\n } else {\n return [\n {\n name: \"0\",\n dvalue: low,\n children: genBinaryChildren(depth - 1, low, mid)\n },\n {\n name: \"1\",\n dvalue: mid,\n children: genBinaryChildren(depth - 1, mid, high)\n }\n ];\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2749,"value":"binaryTreeOfIntervals = ({\n name: \"0.\",\n dvalue: 0,\n children: genBinaryChildren(9)\n})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2699,"value":"chart = Icicle(binaryTreeOfIntervals, {\n size: null, // (d) => d.size, // size of each node (file); null for internal nodes (folders)\n showValue: false,\n label: (d) => d.name, // display name for each cell\n title: (d, n) =>\n `${n\n .ancestors()\n .reverse()\n .map((d) => d.data.name)\n .join(\"\")}`, // hover text // \\n${n.value.toLocaleString(\"en\")}\n width: 800,\n height: 512,\n padding: 0,\n color: (t) => d3.interpolateGreys(1 - t),\n fillOpacity: 0.7\n})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2694,"value":"$4d","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2891,"value":"rationals9 = generateAllNumbersBreadthFirst(514, false)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":2886,"value":"bTreeOfDigits = vlembed(\n makeTreeVegaSpec(rationals9.tree, {\n title: `Infinite Binary Tree of Digits (to depth 9)`,\n width: 800, // + infiniteBinaryTreeOfDigitsOptions.depth * 10,\n height: 512,\n padding: 0,\n hideLabels: true // infiniteBinaryTreeOfDigitsOptions.depth > 7\n })\n)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W4e","stdlib":"1","titling":"auto"}} 33:"$32:body"