- Code: Select all
0001 = 1
0002 = 2
0003 = 3
0004 = 2 <2> 1
0005 = 1 <1> (2 <1> 2)
0006 = 3 <1> 1
0007 = 1 <1> (3 <1> 2)
0008 = 2 <2> 2
0009 = 3 <2> 1
0010 = 2 <1> (2 <2> 1)
0011 = 1 <1> (1 <1> (3 <2> 1))
0012 = 3 <1> 3
0013 = 1 <1> (3 <1> 3)
0014 = 2 <1> (3 <1> 1)
0015 = 3 <1> (2 <2> 1)
0016 = 2 <2> 3
0017 = 1 <1> (2 <2> 3)
0018 = 2 <1> (2 <2> 2)
0019 = 1 <1> (2 <1> (2 <2> 2))
0020 = (2 <2> 1) <1> (2 <2> 1)
0021 = 3 <1> (2 <2> 2)
0022 = 2 <1> (2 <1> (2 <2> 1))
0023 = 1 <1> (2 <1> (2 <1> (2 <2> 1)))
0024 = (2 <2> 1) <1> (1 <1> (2 <1> 2))
0025 = (1 <1> (2 <1> 2)) <2> 1
0026 = 2 <1> (3 <1> 3)
0027 = 3 <3> 1
0028 = 1 <1> (3 <3> 1)
0029 = 1 <1> (1 <1> (3 <3> 1))
0030 = 3 <1> (3 <2> 1)
0031 = 1 <1> (3 <1> (3 <2> 1))
0032 = 2 <2> (2 <2> 1)
0033 = 3 <1> (2 <1> (2 <2> 1))
0034 = 2 <1> (2 <2> 3)
0035 = (1 <1> (2 <1> 2)) <1> (3 <1> 1)
0036 = (3 <1> 1) <2> 1
0037 = 1 <1> ((3 <1> 1) <2> 1)
0038 = 2 <1> (2 <1> (2 <2> 2))
0039 = 1 <1> (2 <1> (2 <1> (2 <2> 2)))
0040 = (2 <2> 2) <1> (2 <2> 1)
0041 = 1 <1> ((2 <2> 2) <1> (2 <2> 1))
0042 = (3 <1> 1) <1> (3 <1> 1)
0043 = 1 <1> ((3 <1> 1) <1> (3 <1> 1))
0044 = (2 <2> 1) <1> (2 <1> (2 <2> 1))
0045 = (3 <2> 1) <1> (2 <2> 1)
0046 = 2 <1> (2 <1> (2 <1> (2 <2> 1)))
0047 = 1 <1> (2 <1> (2 <1> (2 <1> (2 <2> 1))))
0048 = (2 <2> 3) <1> 2
0049 = (1 <1> (3 <1> 2)) <2> 1
0050 = (1 <1> (2 <1> 2)) <1> (3 <2> 1)
0051 = 1 <1> ((1 <1> (2 <1> 2)) <1> (3 <2> 1))
0052 = 2 <1> ((1 <1> (2 <1> 2)) <2> 1)
0053 = 1 <1> (2 <1> ((1 <1> (2 <1> 2)) <2> 1))
0054 = (2 <2> 2) <1> (3 <1> 1)
0055 = (1 <1> (2 <1> 2)) <1> (2 <1> (2 <2> 1))
0056 = 2 <1> (3 <3> 1)
0057 = 1 <1> (2 <1> (3 <3> 1))
0058 = 2 <1> (1 <1> (3 <3> 1))
0059 = 1 <1> (2 <1> (1 <1> (3 <3> 1)))
0060 = 3 <1> (3 <2> 1)
Notice that as the numbers go up, the length of the expression to represent it becomes more erratic. Therefore, you could have very large numbers represented by short strings. The reason I've only used the numbers 1, 2 and 3 is to show that even when reduced to only 3 different numbers it still never reaches more than 5 operators by the time we get to 60. Rewritten using the numbers 1-9, the list becomes:
- Code: Select all
0001 = 1
0002 = 2
0003 = 3
0004 = 4
0005 = 5
0006 = 6
0007 = 7
0008 = 8
0009 = 9
0010 = 2 <1> 4
0011 = 1 <1> (1 <1> 9)
0012 = 3 <1> 3
0013 = 1 <1> (3 <1> 3)
0014 = 2 <1> 6
0015 = 3 <1> 4
0016 = 2 <2> 3
0017 = 1 <1> (2 <2> 3)
0018 = 2 <1> 8
0019 = 1 <1> (2 <1> 8)
0020 = 4 <1> 4
0021 = 3 <1> 8
0022 = 2 <1> (2 <1> 4)
0023 = 1 <1> (2 <1> (2 <1> 4))
0024 = 4 <1> 5
0025 = 5 <2> 1
0026 = 2 <1> (3 <1> 3)
0027 = 3 <3> 1
0028 = 1 <1> (3 <3> 1)
0029 = 1 <1> (1 <1> (3 <3> 1))
0030 = 3 <1> 9
0031 = 1 <1> (3 <1> 9)
0032 = 2 <2> 4
0033 = 3 <1> (2 <1> 4)
0034 = 2 <1> (2 <2> 3)
0035 = 5 <1> 6
0036 = 6 <2> 1
0037 = 1 <1> (6 <2> 1)
0038 = 2 <1> (2 <1> 8)
0039 = 1 <1> (2 <1> (2 <1> 8))
0040 = 8 <1> 4
0041 = 1 <1> (8 <1> 4)
0042 = 6 <1> 6
0043 = 1 <1> (6 <1> 6)
0044 = 4 <1> (2 <1> 4)
0045 = 9 <1> 4
0046 = 2 <1> (2 <1> (2 <1> 4))
0047 = 1 <1> (2 <1> (2 <1> (2 <1> 4)))
0048 = (2 <2> 3) <1> 2
0049 = 7 <2> 1
0050 = 5 <1> 9
0051 = 1 <1> (5 <1> 9)
0052 = 2 <1> (5 <2> 1)
0053 = 1 <1> (2 <1> (5 <2> 1))
0054 = 8 <1> 6
0055 = 5 <1> (2 <1> 4)
0056 = 2 <1> (3 <3> 1)
0057 = 1 <1> (2 <1> (3 <3> 1))
0058 = 2 <1> (1 <1> (3 <3> 1))
0059 = 1 <1> (2 <1> (1 <1> (3 <3> 1)))
0060 = 3 <1> 9
Now, the reason I've left it only using the numbers 1-9 is because this way it can be shortened even more. By removing all the angle brackets and spaces, leaving only numbers and brackets, we get the following:
- Code: Select all
0001 = 1
0002 = 2
0003 = 3
0004 = 4
0005 = 5
0006 = 6
0007 = 7
0008 = 8
0009 = 9
0010 = 214
0011 = 11(119)
0012 = 313
0013 = 11(313)
0014 = 216
0015 = 314
0016 = 223
0017 = 11(223)
0018 = 218
0019 = 11(218)
0020 = 414
0021 = 318
0022 = 21(214)
0023 = 11(21(214))
0024 = 415
0025 = 521
0026 = 21(313)
0027 = 331
0028 = 11(331)
0029 = 11(11(331))
0030 = 319
0031 = 11(319)
0032 = 224
0033 = 31(214)
0034 = 21(223)
0035 = 516
0036 = 621
0037 = 11(621)
0038 = 21(218)
0039 = 11(21(218))
0040 = 814
0041 = 11(814)
0042 = 616
0043 = 11(616)
0044 = 41(214)
0045 = 914
0046 = 21(21(214))
0047 = 11(21(21(214)))
0048 = (223)12
0049 = 721
0050 = 519
0051 = 11(519)
0052 = 21(521)
0053 = 11(21(521))
0054 = 816
0055 = 51(214)
0056 = 21(331)
0057 = 11(21(331))
0058 = 21(11(331))
0059 = 11(21(11(331)))
0060 = 319
This is very space-saving to store in a computer, as since there are only 11 different symbols it can be stored with two characters per byte. With very large numbers this would be useful. Consider one googolplex, 10^(10^100). A computer currently would be unable to store this number. However, if we convert it to this notation, one google, 10^100 is ten multiplied by itself 99 times. 99 is too large - so we reduce it to 9 added to itself 10 times. 10 is also too large, so we reduce it to 2 added to itself 4 times.
Thus, we get:
10 = 2 <1> 4
99 = 9 <1> (2 <1> 4)
10^100 = (2 <1> 4) <2> (9 <1> (2 <1> 4))
10^(10^100) = (2 <1> 4) <2> ((2 <1> 4) <2> (9 <1> (2 <1> 4)))
Shortening this reduces it to "(214)2((214)2(91(214)))", which being only 23 characters long can be stored in only 12 bytes of data.
The general rule for the string of characters is "In each group of numbers, where a group is everything between one "(" and its respective ")" exclusively, only 3 numbers or groups are allowed, no more and no less."
Given this rule I will now generate a completely random valid string of characters to prove that it can be expanded to angle-bracket notation:
"23((628)7(5(187)(95(751))))" - 27 characters, occupying 14 bytes
expands to 2 <3> ((6 <2> 8) <7> (5 <(1 <8> 7)> (9 <5> (7 <5> 1))))
This must be a huge number, as (7 <5> 1), or seven hyper-5ed to itself 1 time, is seven hyper-4ed to itself seven times, which expands to:
- Code: Select all
7 ^ (7 ^ (7 ^ (7 ^ (7 ^ (7 ^ (7 ^ 7))))))) ^ (7 ^ (7 ^ (7 ^ (7 ^ (7 ^ (7 ^ 7))))))) ^ (7 ^ (7 ^ (7 ^ (7 ^ (7 ^ (7 ^ 7))))))) ^ (7 ^ (7 ^ (7 ^ (7 ^ (7 ^ (7 ^ 7))))))) ^ (7 ^ (7 ^ (7 ^ (7 ^ (7 ^ (7 ^ 7))))))) ^ (7 ^ (7 ^ (7 ^ (7 ^ (7 ^ (7 ^ 7))))))) ^ (7 ^ (7 ^ (7 ^ (7 ^ (7 ^ (7 ^ 7)))))))
As you can see, this is very obviously one of the hugest numbers ever imagined. Then we have 9 <5> n, 9 hyper-5ed to itself n times, where n is the very long expression composing of sevens written above, which must be zillions of times larger itself.
A note to be said here is that if, in (a <b> c), a is 1, then that expression can simply be replaced by 1. The only exception is addition: one added to itself ten times is eleven, but one multiplied, exponented or even hyper-n-ed to itself ten times is still 1. Thus we can replace the <(1 <8> 7)> in the previous expression by <1>.
Well, that was yet another very long post from me. What does everybody think about this notation?