> You have fifteen seconds. Using standard math notation, English words, or both, name a single whole number—not an infinity—on a blank index card. Be precise enough for any reasonable modern mathematician to determine exactly what number you’ve named, by consulting only your card and, if necessary, the published literature.
Lol, we used to do this with my (extremely nerdy) friends group in college when we 'inducted' new members! I never knew that it was from something, I just thought it was tradition. We had some great entries -- a circle of nines with no beginning and ending, a very good drawing of a wolf, many protest entries, somebody accidentally wrote 1^1^1^1^1^... before realizing their folly, etc. Great times.
`9↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑9` seems like a reasonable guess (barring encoding cheats/trickery like @masfuerte commented!)
Edit: I've misread the above comment and my number is is 64 bytes (significantly more than 64 bits. The largest 64 bit number through my approach would be `9↑↑↑↑↑↑9`, which is significantly smaller.
I'm going to agree with the downvoted people and say that this sort of approach is largely meaningless if you allow arbitrary mappings. IMO the most reasonable mathematical formulation given the structure of the integers (in the sense of e.g. Peano) is that to truly represent an integer you have to represent zero and each other representable number has a representable predecessor, i.e. to say you can represent 5 you need 0,1,2,3,4, and 5 to be representable. By a straightforward counting argument, 2^64-1 is then the largest representable number, in other words the obvious thing is right.
It all goes over my head, but, what does the distribution of values look like? e.g. for unsigned integers its completely flat, for floating point its far too many zeros, and most of the numbers are centered around 0, what do these systems end up looking like?
Please no more comments to the extent of "i can define a much larger number in only 1 bit". What makes my blog post (hopefully) interesting is that I consider tiny programs for computing huge numbers in non-cheating languages, that are not specifically equipped for doing so.
> What if we allow representations beyond plain data types? Since we want representations to remain computable, the most general kind of representation would be a program in some programming language. But the program must be small enough to fit in 64 bits.
If you bring in a whole programming language, you bring in a lot more than 64 bits. This all seems to be the math equivalent of saying you wrote a program in 2k when the first line is "import 'megalibrary'".
To the author: this work you've published rests on some background knowledge that I'm familiar with but also a lot of background knowledge that's foreign to me. For the parts I was able to follow, I thought the mental gear-turning was enjoyable and interesting! But pursuing these intersections between algebra and computer science is often not so interesting, at least, when I research it myself. Is this something you've learned in university? I ask because I fear that without a formal learning environment, I may never pick up on the more advanced logic halfway through the article. Anyway, cheers to the good work.
In a sense, this is just an exercise in (possibly lossy) compression. 64-bit unsigned into are not lossy. 64-bit floating point is lossy but has larger range; it’s only able to encode a small fraction of the numbers in its range (in the limit, the fraction that can be represented is zero since there are infinite real numbers in the range and FP only captures a few).
Busy Beaver gets a lot of love, but the fast growing hierarchy is both constructive and can go way, way, waaaaay beyond current known BB bounds. This makes their size much more viscerally apparent than gesturing vaguely at BB(BB(BB(100))) or whatever, IMHO.
David Metzler has this really cool playlist "Ridiculously Huge Numbers" that digs into the details in an accessible way:
By the end, you're thinking about functions that grow so fast TREE is utterly insignificant. Surprisingly, getting there just needs a small bit of machinery beyond Peano Arithmetic [0].
Then you can ponder doing all that but making a tiny tweak by replacing succesorship with BB. Holy cow...
every time i’m hacking around with no idea what the program might be, i really should be working on a “thank you, world!” program,
to cultivate gratitude and humility
all those whose work has made it such that i can say “hellos commonlisp what is the most positive fixnum or word or whatever!” or totally not even think about that let alone complex allocations that seem to happen automatically relative to me
they’re cool as f**! i should do well not to forget this.
Proof:
There is no larger number than +∞.
Is +∞ a number? Yes, it is. It is not a real number, it is not a representative number, it's a hyperreal number. (Kreisler 1986)
the largest number representable in 1 bit is any number
(including +infinity and beyond).
This article describing various Rube Goldberg machines, there is no need to agree on different ways of representing numbers when one can set a single bit to 1 to represent any desired pre-defined number, or 0 to represent its absence (or the number 0).
A Rube Goldberg machine is one intentionally designed to perform a simple task in a comically overcomplicated way, usually consisting of a series of simple unrelated devices.
Programs like Melo and w128 are the opposite, performing a hard task with the simplest means, using only a few highly inter-related parts.
Your proposed representation is exactly the kind of cheating, to get the results you want, that the article purposely avoids.
the article misses log-math and log-log-math which
would use 64-bit (d)oubles are exponents in 10^d and 10^(10^d) respectively,
which allows far higher range of possible values but somewhat more
awkward math operations(addition/subtraction), though much more practical & faster to compute.
31 comments
[ 3.5 ms ] story [ 55.0 ms ] threadIn my representation the bit pattern 00000000_00000000_00000000_00000000_00000000_00000000_00000000_00000001 stands for the number w218+1.
I win!
Lol, we used to do this with my (extremely nerdy) friends group in college when we 'inducted' new members! I never knew that it was from something, I just thought it was tradition. We had some great entries -- a circle of nines with no beginning and ending, a very good drawing of a wolf, many protest entries, somebody accidentally wrote 1^1^1^1^1^... before realizing their folly, etc. Great times.
Everything else is word play.
https://mathworld.wolfram.com/KnuthUp-ArrowNotation.html
Edit: I've misread the above comment and my number is is 64 bytes (significantly more than 64 bits. The largest 64 bit number through my approach would be `9↑↑↑↑↑↑9`, which is significantly smaller.
0=your largest number 1=your largest number + 1
> What if we allow representations beyond plain data types? Since we want representations to remain computable, the most general kind of representation would be a program in some programming language. But the program must be small enough to fit in 64 bits.
If you bring in a whole programming language, you bring in a lot more than 64 bits. This all seems to be the math equivalent of saying you wrote a program in 2k when the first line is "import 'megalibrary'".
The largest number representable in 64 bits - https://news.ycombinator.com/item?id=38414303 - Nov 2023 (105 comments)
The largest number representable in 64 bits - https://news.ycombinator.com/item?id=35677148 - April 2023 (42 comments)
(I haven't put 2023 in the current title since the article says it's been significantly expanded since then.)
David Metzler has this really cool playlist "Ridiculously Huge Numbers" that digs into the details in an accessible way:
https://www.youtube.com/playlist?list=PL3A50BB9C34AB36B3
By the end, you're thinking about functions that grow so fast TREE is utterly insignificant. Surprisingly, getting there just needs a small bit of machinery beyond Peano Arithmetic [0].
Then you can ponder doing all that but making a tiny tweak by replacing succesorship with BB. Holy cow...
[0]:https://en.wikipedia.org/wiki/Theories_of_iterated_inductive...
every time i’m hacking around with no idea what the program might be, i really should be working on a “thank you, world!” program,
to cultivate gratitude and humility
all those whose work has made it such that i can say “hellos commonlisp what is the most positive fixnum or word or whatever!” or totally not even think about that let alone complex allocations that seem to happen automatically relative to me
they’re cool as f**! i should do well not to forget this.
thank you for sharing
Proof: There is no larger number than +∞. Is +∞ a number? Yes, it is. It is not a real number, it is not a representative number, it's a hyperreal number. (Kreisler 1986)
the largest number representable in 1 bit is any number (including +infinity and beyond).
This article describing various Rube Goldberg machines, there is no need to agree on different ways of representing numbers when one can set a single bit to 1 to represent any desired pre-defined number, or 0 to represent its absence (or the number 0).
Programs like Melo and w128 are the opposite, performing a hard task with the simplest means, using only a few highly inter-related parts.
Your proposed representation is exactly the kind of cheating, to get the results you want, that the article purposely avoids.
0x6269676773657403
I win
:)