One day a few years ago, while waiting for my dinner, I started doodling with prime numbers, and I came across an interesting question. Here’s how it came about.
When translating a number from binary to decimal notation by hand, you add together a series of products. For example:
Each binary digit is multiplied by a discrete value, that is, a power of 2. Naturally, each string of binary digits corresponds to a unique “real life” (i.e. decimal) number. Could there be an alternate way of “translating” these digits to express a unique product of primes?
That is, instead of each binary digit representing a power of two, it would instead represent a prime number. For example:
In this case, each string of binary digits would again correspond to a unique “real life” number. For example, if you wanted a “binary” string to express ten, you would need the prime factorization of ten:
Of course, a problem arises when you try to do this for a number whose factors include a prime power greater than one. (For example, 18). One option would be to change the “binary” nature of the expression to an arbitrarily higher base, for example, ten, like so:
But of course, any number with a factor that is the tenth or eleventh power of something could not be expressed this way, so we’re back to square one.
A more satisfying approach would be to create slots for squares of primes, primes to the 4th power, primes to the 8th power, etc., so that there would be no need for a value other than 0 or 1. Therefore, in addition to having digits representing 2, 3, 5, 7, 11, etc., there would also be digits representing 4, 9, 25, 49, etc., 16, 81, 625, etc., 256, etc. and so on.
For lack of a better term, I call these numbers metaprimes. They all follow the form p2n, where p is prime and n is a non-negative integer. Here are the first few of these metaprimes: 2, 3, 4, 5, 7, 9, 11, 13, 16, 17, 19, 23, 25, 29, 31, 37, 41, 43, 47, 49, 53... (True primes are in black.)
Every integer greater than 1 can be expressed as the product of these metaprimes, using each metaprime no more than once.
Using this scheme, we could represent the decimal number 120 like so:
Note that using metaprimes, we don’t need to use any factor more than once. If we assign each binary digit to a metaprime (right-most digit represents 2, second-right-most digits represents 3, etc.), we can continue like so:
Likewise, we could represent the decimal number 128 like so:
Now here’s where things get interesting. These metaprime binary expressions look just like regular binary expressions, so what happens if we encode a regular decimal number into metaprime binary, then treat that result as a regular binary expression, then translate it back to decimal? For example, let’s try 18:
So 18 becomes 33. Let’s try it again:
So 33 becomes 66. One more time:
We can also do it in reverse. Let’s start with zero this time:
So zero becomes one. This makes sense, since 0 is considered the “additive identity” (regular binary is additive) and 1 is considered the “multiplicative identity” (metaprime binary is multiplicative.) Let’s try it again:
So one becomes two. Once more:
And two becomes three. If we keep doing this, we get the following series:
0, 1, 2, 3, 6, 12, 20, 28, 140, 260, 64, 11, 30, 420, 7488, 1922800, ...
After 1922800, the numbers grow logarithmically, approximating 253, 2125, 2413, and so on. There are a few numbers that either convert to themselves or switch back and forth, producing series like these:
4, 4, 4, 4... (binary 100)
However, most series spiral out to enormous values rapidly. Here are the next few:
7, 24, 35, 54, 756, 612612, 2291867200, ~264, ~2176, ~2684, ~23352, ~222464
If you go in the reverse direction, the same thing happens, but quicker:
7, 16, 256, 262
(Zero is the only non-negative integer without a “reverse” counterpart in this scheme.)
If you were to graph these series, you would likely see a jerky parabola leaning to the right for most of these. Graphing the logs of the elements in the series smoothes it out some:
Here are some open questions about these series.
I wrote a little C++ program to help me with the elements of the series that I couldn’t easily do by hand (such as ~264), but it is slow and clunky and uses a Large Integer class I developed specifically for this problem. Sometime I may re-write it, deriving one of the better Large Integer classes out there, but probably not anytime in the near future.
Comments or questions (or answers?) E-mail me.
This page created 1/30/2003.