## 8/11/12

### infinity

Here is a game I play sometimes. I try to imagine ways of organizing one's. The game usually goes like this.
• 1
• 11
• 111
• we see a pattern here, and we can invent a compressed way to write it, like "rep(1)", which means "repeat the number 1 an infinite number of times"
• rep(1)
• rep(rep(1))
• rep(rep(rep(1)))
• we see another pattern here. we're getting deeper and deeper nested calls of "rep", but the "rep" notation itself is not expressive enough to represent this, so we need a new way to compress this information. Let's represent this as "rec(rep, 1)", i.e., an infinite number of recursive calls to "rep" with a base case of "1".
• rec(rep, 1)
• rec(rep, rec(rep, 1))
• rec(rep, rec(rep, rec(rep, 1)))
• we see another pattern here of recursively calling repeat on recursively calling repeat again and again.. unfortunately this pattern is not expressible in terms of just "rec" and "rep" as we've defined them. We need something new, again. Let's express the infinite application of "rec" and "rep" to 1 as "rec2(rec, rep, 1)"
• rec2(rec, rep, 1)
• rec2(rec, rep, rec2(rec, rep, 1))
• rec2(rec, rep, rec2(rec, rep, rec2(rec, rep, 1)))
• we see another pattern here, and we could imagine that the next thing to do is...
• rec3(rec2, rec, rep, 1)
• ...and then...
• rec4(rec3, rec2, rec, rep, 1)
• which is a pattern in itself, of repeatedly inventing "rec" functions with larger and larger numbers of arguments.. we might collapse this whole business into "superRec(rep, 1)"
• superRec(rep, 1)
• superRec(rep, superRec(rep, 1))
• superRec(rep, superRec(rep, superRec(rep, 1)))
• rec2(superRec, rep, 1)
• rec3(rec2, superRec, rep, 1)
• rec4(rec3, rec2, superRec, rep, 1)
• now we see a similar pattern to "rec4(rec3, rec2, rec, rep, 1)", except there's a "superRec" where we had "rec".. we could represent the infinite extension of this new pattern as "superRec2(superRec, rep, 1)"
• superRec2(superRec, rep, 1)
• superRec2(superRec, rep, superRec2(superRec, rep, 1))
• superRec2(superRec, rep, superRec2(superRec, rep, superRec2(superRec, rep, 1)))
• rec3(superRec2, superRec, rep, 1)
• rec4(rec3, superRec2, superRec, rep, 1)
• now we see a similar pattern to "rec4(rec3, rec2, superRec, rep, 1)", except there's a "superRec2" where we had "rec2".. we can guess that eventually all of our "recN"'s will be replaced with "superRecN"'s, and we can represent that whole mess as "uberRec(rep, 1)"
• uberRec(rep, 1)
• uberRec(rep, uberRec(rep, 1))
• uberRec(rep, uberRec(rep, uberRec(rep, uberRec(rep, 1))))
• rec2(uberRec, rep, 1)
• rec3(rec2, uberRec, rep, 1)
• rec4(rec3, rec2, uberRec, rep, 1)
• so we went from "rec4(rec3, rec2, rec, rep, 1)" to "rec4(rec3, rec2, superRec, rep, 1)" to "rec4(rec3, rec2, uberRec, rep, 1)".. we can guess that we're going to need something like "ultraRec" and then "megaRec" and eventually we'll run out of words, so instead of "super" and "uber" and "ultra" and "mega" we'll call them "super1Rec", "super2Rec", "super3Rec", and the infinite extension of them we'll call "superInfiniteRec"
• superInfiniteRec(rep, 1)
• superInfiniteRec(rep, superInfiniteRec(rep, 1))
• superInfiniteRec(rep, superInfiniteRec(rep, superInfiniteRec(rep, superInfiniteRec(rep, 1))))
• so this seems like it's going to lead us to something like "superInfiniteRec2" and "superInfiniteRec3", which we'll eventually call "uberInfiniteRec" and then "ultraInfiniteRec", and then we'll replace the "uber"'s and "ultra"'s with "super2"'s and "super3"'s and eventually "superInfinite" giving us "superInfiniteInfiniteRec"
• superInfiniteInfiniteRec(rep, 1)
• superInfiniteInfiniteInfiniteRec(rep, 1)
• superInfiniteInfiniteInfiniteInfiniteRec(rep, 1)
• now there's an obvious pattern here.. repeated use of the word "Infinite" in our function name. However, it is less clear how to represent the infinite extension of it.. we might try something like "super[rep("Infinite")]Rec(rep, 1)"
• super[rep("Infinite")]Rec(rep, 1)
• super[rep(rep("Infinite"))]Rec(rep, 1) whatever that means
• super[rec(rep, "Infinite")]Rec(rep, 1)
• super[superRec(rep, "Infinite")]Rec(rep, 1)
• super[super[rep("Infinite")]Rec(rep, "Infinite"))]Rec(rep, 1)
• super[super[super[rep("Infinite")]Rec(rep, "Infinite"))]Rec(rep, "Infinity")]Rec(rep, 1)
• um.. now I'm pretty sure this notation still has meaning, and I can see a new pattern, but it seems like expressing this pattern will be even messier. Maybe it would be easier if I had made some different notation choices above..
The interesting thing is that I keep needing to invent new notations to represent new organizational concepts. In fact, I doubt that there exists any "clean" notation that keeps working in some sensical self-consistant manner forever. Weirder still, I think the game can be played, in theory, past the ability to create notations. That is to say, the number of iterations of this game may be uncountable (I'm pretty sure it is, I just haven't proven it myself). I think this is what the Church-Kleene ordinal is talking about.

Now, in the game above, I start with "1", "11", "111", which one could think of as "1", "2", "3". In this case, one could think of "rep(1)" as the number that comes after all the integers, and "rep(1) 1" as the number after that, on and on.. hence, you can use this game as a way of generating numbers to count things with. In mathematics, these numbers are called ordinals, where Cantor normal form is one way of expressing them (where my "rep(1)" would be "ω", and my "rep(1) 1" would be "ω + 1", and my "rep(1) rep(1)" would be "2ω", and my "rec(rep, 1)" as "ω2", or something like that).

Now, there's a notation for talking about levels of infinity, or "cardinals". The countable infinity is called אa0, in Aleph notation, and אa1 represents the uncountable real numbers. You can keep counting אa2, אa3, אa4, and eventually אaω, אaω+1, ... אa, ... אaω2. Notice that the ordinals act as subscripts for the cardinals.

Now how many cardinals are there? Presumably there are uncountably many, since there are uncountably many ordinals for use as subscripts. But we don't mean uncountable in the אasense -- rather we mean not-countable, but probably larger than אa1, or in fact any cardinal.

So in summary, the game of making things bigger can be played "infinitely", but not in the way I would have thought. I would have thought it could be played "infinitely" in the sense that I could keep coming up with something bigger, but in fact, it can be played to the point where I can't come up with something bigger, and yet there still is something bigger -- I just can't come up with it, due to the limitations of notation while living in a אa0 or possibly אa1 sized world.