The infinite-pixel screen | Hacker News Reader

The infinite-pixel screen

practicaltypography.com

36 pointslispython86 comments

There's a really good book by David Foster Wallace called Everything and More: A Compact a history of Infinity that traces the origin of the concept and the numerous difficulties the idea faced before becoming more or less accepted as it is today. Highly recommended if you like reading or math.

Interstingly, Wallace takes a similar attitude towards those not keen on the details of the Math. There are large swaths where he basically says, "skip this if it makes your head hurt, you won't be missing any of the story."

@refrigerator, some of us come from all kinds of different backgrounds and didn't study this in school and wouldn't know anything at all about it if not for books like the one I mentioned above. Who knows? Perhaps Butterick has sparked an interest in some typographer who's never thought about the concept.

I'm wondering... can't you map all infinite binary strings to all positive integers? If the rightmost digit is the 1s column, the next rightmost digit is the 2s column, and so on, you're just enumerating all possible positive integers. And each time you double (or quadruple) your pixels, you add one (or two) digits in front, getting bigger and bigger integers. But this always stays in the set of integers, which is countable. Am I missing something here? To me, this bijection makes it clear that you'll get a countable number of pixels with a countable number of doublings.

Yes, I don't understand how he created an infinite number of binary strings, and suddenly flipping one bit means that the binary string is new?

Surely the flipped bit binary string would already appear in the infinite list?

> I don't understand how he created an infinite number of binary strings, and suddenly flipping one bit means that the binary string is new?

That's not quite what the diagonal argument does.

Take an enumerated list of infinite binary strings, i.e., the strings are numbered as string #1, #2, #3, etc. Now construct a new infinite binary string in the following way: bit #1 of the new string is the opposite of bit #1 of string #1; bit #2 of the new string is the opposite of bit #2 of string #2; bit #3 of the new string is the opposite of bit #3 of string #3; etc. This new string cannot possibly appear in the list, because for all positive integers n, bit #n of the new string differs from bit #n of binary string #n in the list--i.e., the new string differs from every string in the list by at least one bit.

In other words, if we are given any list of infinite binary strings enumerated by positive integers, we can always construct a new infinite binary string that is not in the list. So no such list can ever be complete. Hence, there must be more infinite binary strings than there are positive integers.

> can't you map all infinite binary strings to all positive integers?

No. Positive integers are represented by finite binary strings, not infinite ones. Cantor's diagonal argument shows that there is no way to construct a one-to-one mapping between positive integers and infinite binary strings.

    Bijection is a simple idea. But it’s an important tool because it helps keep us 
    out of the counterintuitive weeds when working with infinite sets. For instance, 
    we can now figure this out: are there more positive integers {1, 2, 3, ...} or 
    even integers {2, 4, 6, ...}? The naive answer would be that there must be more 
    positive integers, because the set of positive integers includes both the even  
    and odd integers.

    But this is wrong. Using bijection, we see that we can put the positive integers 
    and even integers into a one-to-one correspondence like so:

    1, 2, 3, 4, ...
    2, 4, 6, 8, ...

Couldn't you also reason that there are more even integers than positive integers if you start with the notion that you start with a number and start counting in the direction(s) of the defined set:

                    X--->
                    1, 2, 3, 4, ...
    ..., -4, -2, 0, 2, 4, 6, 8, ...
                 <--X-->

The set of all integers progresses along two vectors with each "count" and only positive increases along a single vector with each count.

As long as the bijection exists at all, the sets have the same cardinality. To prove two sets don't have the same cardinality, the most direct way is to prove that such a bijection is impossible.

Anyway, the bijection from counting numbers to the set of all natural numbers is easy:

    1, 2,  3, 4,  5, ...
    0, 1, -1, 2, -2, ...

The idea is that if there is any bijection at all between the two sets then they are the same "size". So you can make all kinds of relations between two sets that are not bijections but once you find one you have satisfied the definition of same size in this sense. Note that it is a way of defining size that corresponds to what we mean with finite sets and then extends that definition in a consistent way.

So yes you could define a "malandrew size" however you like and see what kind of insights you get.

You have an infinite number of both since the counting never ends. In your example, if you've counted n positive integers, you've counted 2n even integers associated with those (by going both ways). But if you continue counting, eventually you will count 2n positive integers (at which point you'll have counted 4n even integers). For any number of even integers that you count, you can just keep counting the positive integers and you'll eventually reach that number.

Here's another way to think about it: are there more positive integers than there are positive integers? (Any "correct" approach should say no, or at least not yes.)

Using your approach, however, here is a proof that there are more positive integers than there are positive integers.

Lets rearrange the positive integers in this manner:

                    X--->
                    1, 2, 3, 4, ...
   ..., 7, 5, 3, 1, 2, 4, 6, 8, ...
                 <--X-->

So an odd counting vector and and even counting vector, both in the positive direction would be equivalent to the approach I suggested. That makes sense. Thanks for the clarification.

This guy is awesome. He has an online book about typography that convinced me stop typing 2 spaces after periods: http://practicaltypography.com/

It has a pretty weak argument for it. It allows two spaces when using a typewriter, even though the spaces are already twice as wide!

Just a guess, but I'm pretty sure that if you have a totally-ordered set (like in your infinite pixel screen, dictionary order on first coordinate followed by second), and all subsets S = {x/ a<=x<=b } are countably infinite, then the set is countably infinite.

A constructive proof of this is probably doable by inspiring oneself off of Hilbert's hotel paradox (http://en.wikipedia.org/wiki/Hilbert%27s_paradox_of_the_Gran...)

Even though this sounds plausible, it's actually false. The counterxample is the first uncountable ordinal ω₁ [1], viewed as a well-ordered set (and thus a fortiori totally ordered). For every a,b in ω₁, the closed interval [a,b] is countable (by definition), but ω₁ itself is not.

[1] https://en.wikipedia.org/wiki/First_uncountable_ordinal

ah, I remember seeing that in a set theory book I was struggling through at one point. Might be worth a second try so that I don't miss this

I think the followup at the end is wrong, unless I'm misreading. Originally all lines at coordinates k/2^n were drawn and the points not on those lines form an uncountable set (also, between any two points a line we drew is separating them). Then at the end the intermediate representations are counted, which is a completely different thing. An infinite binary tree has countably many nodes and uncountably many paths, yes. The article was fine the way it was.

> points not on those lines form an uncountable set

What do you mean? A countable set of lines cuts the screen into a nonsensical "set of regions", you can't do it.

The infinite pixel scanline is the set of all finite paths (it's all *terminating binary strings), not the set of all infinite paths. Since the set of cutlines is dense, you can actually name all regions, so the only sensible way to assign pixels is to assign a pixel to every line, not to the space between lines (since there is no nonzero space between lines)

>A countable set of lines cuts the screen into a nonsensical "set of regions", you can't do it.

No, it (the set of lines in question) cuts the screen into a set of points (not regions) -- all the points without a coordinate of the form k/2^n.

> I think the followup at the end is wrong

I think so too, but maybe not for the same reason you do.

The original argument of the article is that there is a one-to-one mapping between the set produced as the end result of an infinite number of "pixel division" operations, and the set of infinite binary strings. Since the latter set is uncountable (by Cantor's diagonal argument), the former must be as well. This argument appears to me to be correct.

The followup retracts the above argument, basically because of this counter-argument:

"just as there’s no way to follow 0.333... until you reach exactly one-third, there’s no way to carve a pixel until you get to the exact point represented by a certain infinite binary string"

However, this counter-argument is incorrect, because it leaves out a key qualifier. There is no way to "follow 0.333... until you reach exactly one-third" in a finite number of steps. If you take an infinite number of steps, you do reach exactly one-third: that is what the statement "one-third is the limit of the repeating decimal 0.333..." means. True, you can't explicitly take an infinite number of steps, but you can calculate, mathematically, what the result would be if you did; that is how we know what the limit points are of sequences like 0.333...

Similarly, "there's no way to carve a pixel until you get to the exact point represented by a certain infinite binary string" in a finite number of steps. But you can do it in an infinite number of steps, and the article explicitly postulates exactly that--an infinite number of pixel divisions. And even though we can't explicitly do an infinite number of pixel divisions, we can still calculate, mathematically, what the result would be if we did. That result is the set of infinite binary strings; that set is the limit point of the sequence of pixel divisions, as the number of divisions goes to infinity, just as one-third is the limit point of the sequence 0.333... as the number of 3's goes to infinity.

Yes, that counter was confusing and kind of wrong.

But the followup is mostly correct.

It is possible to carve pixels into uncountably more pixels, but you need uncountably many lines to do it.

Division by countably many lines, aka rational division, does not increase cardinality.

The cardinality of rational numbers is the same as the cardinality of integers.

In your post what is your definition of pixel?

> Division by countably many lines, aka rational division, does not increase cardinality.

I understand that this sounds plausible, but I'm not sure it's true. The real numbers, which are uncountable, can be defined as the set of all limit points of countably infinite series of rational numbers. So the set of countably infinite sums is uncountable. Similarly, I think the set of countably infinite divisions is uncountable.

Here's another way of looking at it: the number of pixels obtained by division by countably many lines is equal to the number of subsets of the rationals--which is uncountable.

But the pixels aren't arbitrary subsets. Look at it in a single dimension for a moment.

p | p | p | p | p | p

There is a dead-obvious 1:1 correspondence between pixels and lines. You could even label each pixel by its bordering line, and then you're literally counting rationals.

It's possible to construct the pixels with an infinite series of rationals, but it's also possible to construct them as a single rational in a countable way.

> the pixels aren't arbitrary subsets.

Doesn't matter. They are the set of all subsets of a countably infinite set (the set of rationals of the form k / 2^n in the 2d example), and any such set of subsets is uncountable. There is a theorem in set theory to this effect.

> There is a dead-obvious 1:1 correspondence between pixels and lines

Yes, but that in itself doesn't show the cardinality of the set of pixels/lines. Nor does it show that the cardinality of the set of pixels/lines when an infinite number of divisions have been made, is the same as the cardinality of the set of pixels/lines when only a finite number of divisions have been made. Assuming that they must be the same is the equivalent of assuming that the cardinality of the reals is the same as the cardinality of the rationals, which is obviously false.

> it's also possible to construct them as a single rational in a countable way

How? Your construction above does not show that.

>Doesn't matter. They are the set of all subsets of a countably infinite set (the set of rationals of the form k / 2^n in the 2d example), and any such set of subsets is uncountable. There is a theorem in set theory to this effect.

They are not the set of all subsets. Not even close. Each pixel is a very particular kind of contiguous subset. You can describe it with one or two rationals (Edit: two or four for 2D).

"Set of all subsets" requires the ability to either include or not include an infinite number of elements independently.

It's obvious that the sets {1,2,3}, {5,6,7}, {9,10,11}, etc. are countable, right? It's a list of subsets of integers but not all subsets.

>How? Your construction above does not show that.

The pixels are defined by their borders, the algorithm for outputting all borders looks like this:

  print 0
  print 1
  d = 2
  loop:
    n = 1
    while n < d:
      print (n / d)
      n += 2
    d *= 2

This constructs all the pixels nice and rationally. Rational numbers are dense, and there are no irrational pixels.

You can define "pixel" however you want, but that has nothing to do with your claim that you can't divide an interval into uncountably many disjoint sets with countably many lines (points).

pdonis and I are not arguing about which way you'd prefer to define the word pixel. But I think pdonis lost the train of what he/she was precisely speaking about in one sentence of the last post.

Edit:

> You can describe it with one or two rationals (Edit: two or four for 2D).

Considering the one-dimensional case for a second: if you define a pixel with two "rationals" (I think you mean two numbers of the form k/2^n here, you're describing (I presume) its left and right boundary, creating an interval (a, b) where a < b. Fine.

How do you describe a pixel with one rational (I think you mean one number of the form k/2^n)? For example, which pixel is described by the rational number 3/8?

Well my argument is that there is a trivial bijection between the disjoint sets and the parallel lines/points.

Do you have a counterargument? I admit I might be making a fundamental mistake but you're going to have to show where.

I edited my post while you wrote this reply.

Edit: And by the way, the immediate direction I'm walking you into with that edit is that, if for some a < b, (a,b) is one of your pixels, then there are no pixel boundaries in that interval (a,b), unless your pixels overlap.

Well it's the non-overlapping pixels that are the interesting case, so let's stick with those. So no a and b, just a. Then I suppose my first attempt to define a pixel would be the zero-width area stating at a, non-inclusive. So the zero width area starting at 3/8, non-inclusive.

Is that fundamentally flawed? (Probably. Edit 2: I mean seriously I have no idea how to handle ranges that are infinitely small. But they clearly exist in some form, I can look at the set of irrational numbers...)

> one rational (I think you mean one number of the form k/2^n)

Yes, in this context. It doesn't really matter if it's k/2^n or any rational, but for consistency's sake let's stick with k/2^n dividers.

Edit: How about this. Is it meaningful to talk about rounding reals to the nearest rational? If not, why not?

> So the zero width area starting at 3/8, non-inclusive.

So yeah, is that just the interval (3/8, 3/8), i.e. the empty set, or what? If it were inclusive, you'd have [3/8, 3/8], which means the same thing as {3/8} -- it's the set that contains just the value 3/8.

> Is it meaningful to talk about rounding reals to the nearest rational? If not, why not?

It is not. The reason is, there is no nearest rational (if it's not already rational). Suppose x is an irrational number, and p is some rational number. Then p != x. That means |x-p| > 0. That means there's some integer n such that 1/n < |x-p|. If p > x, then x < (p - 1/n) < p. If p < x, then p < (p + 1/n) < x. In each case we've constructed a rational number (p-1/n or p+1/n) that is closer to x than p was.

In general, between any two irrational numbers, there's infinitely many rational numbers, and between any two rational numbers, there's (uncountably) infinitely many irrational numbers.

> is that the empty set

Pretty much. It was not the most accurate first attempt. I was hoping to find a way to fix it.

> no rounding

Well that argument is the obvious answer yes, but it requires a certain framework.

Kind of like arguing that there is no biggest number, but there is ω...

Anyway I accept that with normal semantics you can't define non-point non-overlapping ranges between dense rationals. I was wrong. Thank you for your time.

> I think pdonis lost the train of what he/she was precisely speaking about in one sentence of the last post.

Yes, I was pressed for time. I agree with the argument you are making in this sub-thread.

> It's possible to construct the pixels with an infinite series of rationals, but it's also possible to construct them as a single rational in a countable way.

Only if you want overlapping pixels or pixels of varying size. Or pixels that are points, in which case you don't need a convoluted recursive mechanism to define where and what they are.

I don't think they have to overlap just because you defined them rationally. I think it just becomes painful to address pixels if you don't have them overlap. I'm not certain on this point, however.

But it's painful to use an infinite string as an address too.

> I don't think they have to overlap just because you defined them rationally.

They don't have to overlap, if you just define them as points or sets of points with zero area, or let them have varying size, or define them as weird subsets of the screen that aren't measurable. If your pixels are rectangles, though, they have to overlap or have varying size.

Edit: I'm taking countable to mean "countably infinite" since this conversation already assumes we're talking about infinite sets of pixels.

Can they be points but only rational points? How can you tell the difference between dense rational points and dense real points?

It seems like you can mark regions of zero size either through countable or uncountable methods...

> Can they be points but only rational points?

They can be, but then the total area of your pixels would be zero. Which is fine, since this isn't a real monitor we're talking about, this is a math monitor. But:

One property of our computer monitor that we'd want is that when displaying white, it should have uniform brightness -- the amount of light emitted from a rectangle R should be proportional to area(R). The total amount of light emitted from the monitor should be nonzero, too. Let's say the area of the whole monitor is 1 and so is the luminosity.

Your pixels are what's emitting light -- they're point-sources? Suppose p is one of your pixels (or its location). Then let's consider a sequence smaller and smaller squares around p, with side lengths 1/20, 1/21, 1/22, 1/23, ... The luminosity of each of these squares of sidelength 1/n must be the square's area, 1/n^2, because the brightness is uniform. So the pixel p must have zero luminosity, because if it had nonzero luminosity, then some very small rectangle around it would be emitting more light than it should be, and the monitor would not have uniform brightness.

From this argument it seems that each pixel's luminosity is zero. And then you can enumerate the pixels, since they form a countable set: p_1, p_2, p_3, .... The luminosity of the whole screen is a countable sum, which is sum[i = 1 to infinity](luminosity(p_i)) = sum[i = 1 to infinity](0) = 0.

So I don't think the idea of dividing a math-monitor into countably many pixels, each with zero area, works. It's OK that the total area of the pixels is zero, but you have to accept non-uniform luminosity or say that the pixels aren't point sources, they "bleed". However, if you have uncountably many pixels, then it's okay if each "pixel" (whatever) has zero luminosity. You only get nonzero luminosity when talking about sets of pixels with nonzero area -- their luminosity on the uniformly bright screen is proportional to the set's area. That's perfectly compatible with intuition -- the same way it's intuitive that the area of a unit square is 1, even though it's an uncountable union of sets having one point each, each of whose area is zero.

Well the other discussion of non-overlapping pixels is definitely teaching me a lot, but I think this settles what the chosen screen should do. It should use overlapped addressing so you can not only put a picture on it with a countably infinite computer, you can put a picture on it with a finite computer.

Agreed.

> But the pixels aren't arbitrary subsets. Look at it in a single dimension for a moment. > p | p | p | p | p | p

It only looks like this with finitely many pixels.

I think your argument implies that the rationals are uncountable, but they aren't, so your argument must be wrong somewhere- I'm too rusty at this to form a nice argument quickly though.

> I think your argument implies that the rationals are uncountable

No, it doesn't. But it does imply that the set of limit points of all countably infinite series of rationals is uncountable. And that's true: that set of limit points is the set of real numbers, which is uncountable.

Right, yes. I was taking the product of the process of subdividing to not actually include the limit points at all. You are only performing the operation a countable number of times, and at each point you only add a finite number of points, so having an uncountable set pop out at the end seems unlikely.

A bonehead way to formalize this:

The first step outputs {0}, the second, {0, 1/2}, the third {0, 1/4, 1/2, 3/4}, etc.

We drop them all into one big set A. A has countably many elements and they all have a finite size: A = {{0}, {1/2}, ... }

If B is the union of A, it has to have every point that could ever be output by the process. B is the result of "running the process to infinity." B is obviously countable since it's the union of countably many finite sets.

If you can think of a way to define running the process to infinity and -including- the limit points, I'd be interested, but the most natural interpretation to me is that the process produces a set that doesn't include the limit points at all.

The points {0, 1/4, 1/2, 3/4, 1}, etc, are the boundaries between pixels, not the pixels themselves.

> I was taking the product of the process of subdividing to not actually include the limit points at all.

That's not correct. The limit point is "the product of the process of subdividing", by definition.

> You are only performing the operation a countable number of times, and at each point you only add a finite number of points, so having an uncountable set pop out at the end seems unlikely.

By this reasoning, the limit point of every sequence of rational numbers would be a rational number, and the set of all such limit points would be countable. But it isn't; it's the set of reals, which is uncountable.

The pixels are not points. The pixels are rational subdivisions of the screen. Rational numbers have the same cardinality as integers.

The article clearly shows how you can give a unique number to every pixel, no matter how small. You can't just ignore that because you have another argument, you have to show how one of two incompatible arguments is wrong.

The article shows how its original argument was wrong. Each specific pixel has a finite string describing it, not an infinite string. Therefore an argument based on infinite strings is wrong.

If there are countably many rounds of division, then there is a vertical (and horizontal) "division" for each path (from the root) in an infinite complete binary tree. The number of paths in an infinite complete binary tree is uncountable, just like the infinitely divided screen is (each "pixel" corresponds to a path in an infinite complete 4-ary tree).

Reified pixels can be described in finite terms, and can be counted.

You can't just say you're at an infinite level of division, and ask for the name of the pixel you're at.

There is a simple bijection between pixels and a subset of rational numbers. You wouldn't say rational numbers are uncountable, would you?

I can make the same sort of tree argument about rational numbers. My set of rational numbers are constructed by multiplying numerator and denominator by ten and then adding 0-9 to the numerator. At each level they can represent any finite string of digits. Surely this is the same cardinality as the pixels.

There is no way to jump to an "infinitely deep" number by this construction. You have to go a step at a time, and then they're clearly countable. In the way that real numbers aren't, because there's no way to generate all real numbers in any order.

TL;DR Edit: Counting finite strings for an infinite time does not actually produce infinite strings. Each pixel is finite.

The word "reified pixel" is only being used by you so if you want to talk about it you need to define what that means.

The number of nodes in your tree is countable. The number of paths in your tree is uncountable.

In the infinitely subdivided pixel case, a node in the tree corresponds to an x,y position at a particular depth (or, even better, the set of pixels within the square at x, y at that depth). That node, though, does not correspond to a pixel because that area is subdivided into many, many more pixels.

Interesting way of putting it.

So if we look at the problem as an infinite-pixel screen with backwards compatibility, then each pixel is a finite node with subnodes for increased resolution.

If we look at the problem as an infinite-pixel screen that has a more pure layout without overlapping addressing, then each pixel can only be reached with an infinite path.

I for one prefer the backwards compatibility, and think it makes more sense in the context of HD->4k->8k.

But that's pretty hilarious if the API for the pixels changes how many you have.

What is a "rational subdivision"? Last I checked any reasonable screen doesn't have overlapping pixels, so I can't think of any reasonable definition of pixel that does what you say they should do. If your pixels disjointly cover almost the whole screen, you've got to have finitely many pixels or pixels of varying size. (Or uncountably many of them.)

The article doesn't give numbers to any of the pixels in the infinite subdivision. All of the pixels numbered in the article get split in half eventually.

> You could take an item out of both bags until you exhausted the supply of one bag. If the other bag was simultaneously empty, then you’d know they had the same cardinality.

Well, since you can't exhaust the supply of an infinite supply of integers, I don't see how using this method is acceptable when trying to find a one-to-one correspondence.

I feel like I may be missing something so would appreciate if someone could chime in.

This is just an analogy to explain why you would want to find a one-to-one correspondence to compare set cardinalities. Pretty much any real-world analogy will break for infinite sets, but it's fairly straightforward to generalize bijections to infinite sets once you realize it's the right thing to do.

I thought for a second that he was going to be able to prove infinite pixels to me, until his argument made no mention of diagonality. It makes me think of the paradox "all horses are brown"[0]. It was entertaining though.

[0]: http://en.wikipedia.org/wiki/All_horses_are_the_same_color

If the pixels are laid out in a grid then each has a coordinate (x, y), where x and y are integers. Then we form a bijection (x, y) <-> x/y and we see that there are as many pixels as rational numbers. We know that the set of rational numbers is countably infinite, so the number of pixels is countably infinite.

> If the pixels are laid out in a grid then each has a coordinate (x, y), where x and y are integers.

This is true for a finite number of divisions of the pixels. But is it still true for an infinite number of divisions?

The set of pixels along the edge of your choice is countable. The reason is basically the same as was given, except it's simpler since you're only subdividing in one dimension. You'll never drop a pixel exactly at 1/3 or anywhere that isn't an integer multiple of a power of 2.

You can identify each pixel by two other pixels along your chosen edges (axes). The set of pairs drawn from countable sets is always countable.

> The set of pixels along the edge of your choice is countable.

It is for a finite number of divisions. But is it for an infinite number of divisions?

You are basically assuming that the limit point of a given sequence must have the same properties as every item in the sequence. That is obviously false; for example, many limit points of sequences of rational numbers are not rational numbers. So you can't just help yourself to the assumption that, because each pixel's coordinates have a certain property after a finite number of divisions, the coordinates will still have the same property after an infinite number of divisions.

Each pixel always starts at coordinate n / 2^k.

There are no limits involved here. Just a construction of an infinite series of rational coordinates.

> Then we form a bijection (x, y) <-> x/y and we see that there are as many pixels as rational numbers.

I don't think that works, though. Take for example these two coordinates:

    (30, 75)
    (90, 225)

Those would both map to the same rational—2/5—and that would make it not a one-to-one mapping.

You're right - good point. For one way, I guess you could let p_i represent the ith prime number (there are infinitely many) and use p_x / p_y instead. Unsure about the other way.

There's a general result that the set of "All pairs of elements from two countable sets" is, itself, countable. (the Cartesian product of two countable sets is countable).

For example, the set of all pairs of natural numbers can be counted something like this:

Nice! I'm convinced now.

There is a way to map each rational to a specific positive integer. First, you need to define a mapping between positives and integers, this is pretty simple.

0 1 2 3 4

0 -1 1 -2 2

in c code: if(x<0) ? (x * -2)-1 : x * 2;

(pretend that's fixed width above)

Next, any rational can be broken down into a unique prime factorization. 4/6 = 2^1 * 3^-1, 4/15 = 2^2 * 3^-1 * 5^-1

From the factorization, define a transform where the exponent for each prime is replaced using the mapping above: so (2^2 * 3^-1 * 5^-1) becomes (2^4 * 3^1 * 5^1) = 240.

Since the original rational can be negative, you'll need to use the first transformation again, so 4/15 = 240, -4/15 = -240, which work out to 480 and 479 respectively.

0 and 1 are left unchanged by the factorization process so 0 maps to 0, 1 to 2, and -1 to 1.

See the continuum hypothesis. The cardinality of the real numbers is two raised to the power of the cardinality of the natural numbers. So: given that there are a countably infinite number of divisions, each doubling the pixel count, there must be uncountably many pixels that result.

This is more obvious if you simply view the "infinite screen" as a bounded region of space with coordinates denoted by pairs of real numbers.

Ordinal and cardinal exponentiation use similar notation, but they don't work the same way. Though it's common to see statements like "ω is the same as \aleph_0," it's misleading, because 2^ω = ω, and thus has lesser cardinality than 2^\aleph_0.