We traditionally use a base-10 numbering system. There are the digits 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9, and after 9 we reset back to 0 and count the number of resets to the left. As an example sequence to demonstrate the numeral systems, I will use the OEIS sequence A000055, starting at the final 1: 1, 2, 3, 6, 11, 23, 47, 106, 235.
Another famous numbering system is base 12, which has two new digits for the values 10 and 11. I’ll use X and E, but they aren’t standardized across places. Some say that it’s better than base 10, but it really isn’t. The sequence is now 1, 2, 3, 6, E, 1E, 3E, 8X, 177.
Bijective base 10 is a numbering system that is similar to ordinary base 10, but instead of a digit A for 0 it has a single digit for 10. Expressions aren’t unique if we allow for decimals to terminate at different lengths due to the implied 0s at the end (e.g. 2 = 1.A = 1.9A = 1.99A = 1.999A). Again, the sequence: 1, 2, 3, 6, 11, 23, 47, A6, 235.
Binary is just base 2. Two is the smallest possible base that actually works. Multiplication can be done with fewer carries, due to any product of digits being also a digit. The numbers do get very long, however that can be mitigated by just using narrow characters for the digits, such as . and |. The sequence: | |. || ||. |.|| |.||| |.|||| ||.|.|. |||.|.||
A mixed radix system is a numbering system where the base is different in each digit. For example, alternating between 6 and 10 gives us the system used by clocks (at least at the seconds/minutes level). (1, 2, 3, 6, 11, 23, 47, 1:46, 3:55).
Roman numerals are kinda just a base 10 system but the digits’ representations are sorta additive but also have subtraction and the digits have different representations depending on which place they appear. It’s also (by some definitions) limited to a maximum of 3999, although you could also allow it to have an unlimited amount of Ms at the start, which makes for a very interesting puzzle: What happens if you sort all possible Roman numerals in alphabetical order? Anyway, the sequence: I, II, III, XI, XXIII, XLVII, CVI, CCXXXV.
Balanced Ternary is like base 3, but it has a digit T for -1 instead of 2. It allows you to write negatives without a negative sign (e.g. -100T1T = T001T1) and do multiplication with very few carries. However, because it has 3 digits, the digits can’t be made as narrow as binary digits. Of course, the sequence: 1, 1T, 10, 1T0, 11T, 10TT, 1T1T, 11T1, 100T01.
Base phi makes each place value phi times the previous. For example, 2 is written as 10.01 in base phi, because 2 = phi + 1/phi^2, and 3 is written as 100.01 for a similar reason. Note that writing “11” anywhere is forbidden, because 1 + phi = phi^2. I’m not doing the sequence because decimal-to-phinary conversion is a bit difficult.
Factoradic is a numbering system where each place counts successively larger factorials. It does require infinitely many digits, but the rate at which it requires them isn’t very fast. And the sequence: 1, 10, 11, 100, 121, 321, 1321, 4120, 14301.
Base 1.5…? In this numbering system, you have digits 0, H, and 1, where H represents one-half. So, for example, 8 is 1H0HH: 1.5^4 + 0.5*1.5^3 + 0*1.5^2 + 0.5*1.5 + 0.5 = 8. This makes numbers even longer than binary. So, the sequence: 1, 1H, 1H0, 1H10, 1H11H, 1H1010H, 1H0HH1H1H, 1H0HH1H0111, 1H0HH1H010H01. I hope I didn’t make any mistakes there.
Bijective Unary. Only one symbol, and you just write it that many times. It’s really easy to add numbers, at the cost of only being able to represent natural numbers. The sequence: 1, 11, 111, 111111, 11111111111, 11111111111111111111111, 11111111111111111111111111111111111111111111111, 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111, 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111.
The fundamental theorem of arithmetic states that every natural number can be factorized into primes in only one way, up to ordering. So, if we just assign each prime a symbol, we can make a system where multiplication is really easy, at the cost of addition being very difficult. It also requires infinite symbols. Again, the sequence: , 2, 3, 23, E, V, G, 2L, 5G.
We could make the above two infinite-digit-requiring notations just call themself when indexing a digit, so that only finitely many digits are needed. So, e.g. the factoradic sequence would be 1, 10, 11, 100, 1(10)1, (11)(10)1, 1(11)(10)1, ((10)0)1(10)0, 1((10)0)(11)01. The prime factorization version could have the x’th prime be written using a digit that represents x, so the sequence there would be , (), (()), ()(()), (((()))), ((())(())), ((())((()))), ()(()()()()), ((()))((())((()))).
Another based on prime factorization: The x’th space represents the x’th prime, 0 is 0, and you can place a – before the whole thing to make it negative. So -[0][[0]] = -3, and [[-[0]]] = sqrt(2). This can represent many important numbers (even irrationals), with the slight downside that addition might not be always possible. I don’t want to do the sequence for this one, because that’d completely skip over the cursed part
What if we want a system that can write any rational number in its range in finitely many digits, but can only write numbers in the range [0,1)? Try Reverse-Factoradic, where each decimal place counts the next reverse factorial. You could glue this system to ordinary factoradic to allow for writing all reals. Instead of the standard sequence I’ve used for the rest of these, I’ll use the reciprocal integers from 1/2 to 1/7: .1, .02, .012, .0104, .01, .003206.
Here’s a similar system to the above: The nth decimal place represents 1/n, but the maximum of each place is 1. For example, 1 is written as 1, 2 can be written as 1.11001, and 3 can be written as 1.11111011100001001010001. I’m not doing the ordinary sequence here because integers get exponentially long. Multiplication in this one still sorta works with few carries (e.g. 1.1 * 1.01 = 1.11001), but any time two of the 1s land on each other, they create even more 1s, which can quickly cause a chain reaction if we aren’t careful.
At this point, we may as well just give every number its own symbol. This system takes the least space of all these systems, with the slight downside that there are no patterns in the operations at all and this font doesn’t have every symbol. Again, the sequence: 1, 2, 3, 6, E, V, G, Ü, Ǯ.
Leave a Reply