
The infinite-pixel screen - lispython
http://practicaltypography.com/the-infinite-pixel-screen.html
======
ianamartin
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.

------
tedsanders
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.

~~~
megablast
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?

~~~
pdonis
_> 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.

------
malandrew

        Bijection is a simple idea. But it’s an im­por­tant tool be­cause it helps keep us 
        out of the coun­ter­in­tu­itive weeds when work­ing with in­fi­nite sets. For in­stance, 
        we can now fig­ure this out: are there more pos­i­tive in­te­gers {1, 2, 3, ...} or 
        even in­te­gers {2, 4, 6, ...}? The naive an­swer would be that there must be more 
        pos­i­tive in­te­gers, be­cause the set of pos­i­tive in­te­gers in­cludes both the even  
        and odd integers.
    
        But this is wrong. Us­ing bi­jec­tion, we see that we can put the pos­i­tive in­te­gers 
        and even in­te­gers into a one-to-one cor­re­spon­dence 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.

~~~
pavas
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-->

~~~
malandrew
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.

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

~~~
Dylan16807
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!

------
rtpg
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...](http://en.wikipedia.org/wiki/Hilbert%27s_paradox_of_the_Grand_Hotel))

~~~
ontario
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](https://en.wikipedia.org/wiki/First_uncountable_ordinal)

~~~
rtpg
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

------
SamReidHughes
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.

~~~
Dylan16807
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.

~~~
cjhopman
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).

~~~
Dylan16807
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.

~~~
cjhopman
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.

~~~
Dylan16807
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.

------
xtrumanx
> You could take an item out of both bags un­til you ex­hausted the sup­ply of
> one bag. If the other bag was si­mul­ta­ne­ously empty, then you’d know they
> had the same car­di­nal­ity.

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.

~~~
daveFNbuck
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.

------
deevus
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](http://en.wikipedia.org/wiki/All_horses_are_the_same_color)

------
HZet0r
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.

~~~
function_seven
> 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.

~~~
HZet0r
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.

~~~
roywiggins
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:

    
    
        1,1
        2,1
        2,2
        1,2
        3,1
        3,2
        3,3
        1,3
        2,3
        ...

------
xigency
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.

~~~
xrayspec
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.

See also the "warning" here:

[http://en.wikipedia.org/wiki/Ordinal_arithmetic#Exponentiati...](http://en.wikipedia.org/wiki/Ordinal_arithmetic#Exponentiation)

~~~
xigency
And here we have issues of ordering and uniqueness. There are multiple
sequences that correspond to any one point, and in the countably infinite
construction, there are points that have no sequence. This is not to say that
the first definition is invalid or that the second definition is invalid.

It is possible to construct an infinite set that does not contain certain
numbers. For example, if the coordinate (1/pi, 1/2) were excluded.

In some ways, what is being described at the end is, instead of a fully-filled
screen, something that looks like this:
[http://en.wikipedia.org/wiki/Algebraic_number#/media/File:Al...](http://en.wikipedia.org/wiki/Algebraic_number#/media/File:Algebraicszoom.png)

------
cooper12
Slightly off topic but: I actually did bail out when I saw the math warning. I
had enough of math and infinities in college and just am not curious right
now. Still, I think it's very interesting how he tailored his blog post to two
audiences: first a general tech/designer audience, and then a second math-
oriented audience. Makes me thing how maybe in the future we can have dynamic
content like a Wikipedia article about a computer science topic that gets more
specific the more programatically/academically inclined the audience is. (As
to how you could identify this, one example is adsense, but users might be
able to fill in or identify their interests themselves) You can't really make
something that fits everyone's purpose perfectly, but it would be a first good
step.

~~~
gumby
> Makes me thing how maybe in the future we can have dynamic content like a
> Wikipedia article about a computer science topic that gets more specific the
> more programatically/academically inclined the audience is.

We already have a mechanism for this, which is simply to get increasingly
nerdly as you go and let the reader bail out (or skip to the next section) as
desired.

Newspaper articles are an extreme form of this, with the first paragraph a
high level summary and then decreasingly relevant paragraphs with the explicit
design objective that the editor / page layer-outer [1] can cut the article
pretty much at any paragraph break. So the reader reads until their interest
is sated and then stops.

Academic articles are (in principle) the extreme opposite of this, with a
summary up front and then a largely coherent mass following.

[0] is the "d" in nerdly (or gnurdly) an MITism? The Mac's spell corrector
doesn't like it.

[1] I have forgotten the word for this archaic job. This person did layout
after the articles had been typeset.

~~~
egypturnash
[1] pasteup? man I got trained in how to paste stuff up with wax and whatnot
in college and deliberately forgot it within seconds because desktop
publishing was so obviously obsoleting that.

------
miduil
Yet another article that is talking about 4k benefits. My primary (and
actually biggest) screen at the moment is a laptop with ~12.5 inches 16:9
1366x768 pixels. I do miss a bigger screen, but I'm ok with this size. I'm
working with a lot of 'spaces' and I'm using a tiling window manager - which
makes things easier.

PS: Tree style tab for firefox is really nice for 16:9 screens, since most
websites are height and not width.

~~~
dragontamer
The 4k screen thing barely plays a role here.

The real discussion is about bijections and infinite sets.

~~~
miduil
Thank's for pointing that out for me. :) I wasn't sure if I should post the
comment, but decided for it - shit happens.

