P12_2-4-B - Tetronomical System

2.4.9

SBIIS SAIBIAN'S TETRONOMICAL -ILLION SERIES

Introduction

Now that we have examined many of the existing -illion systems that have been devised, I would like to present my own system. Before I get into a full description, I want to lay down its theoretical framework and the "problem" that it tries to resolve.

In the last article when I examined how Bowers' -illion series could be extended to include all the intermediate names in his series, an interesting structure was revealed: That of the tier-construction. Bowers manages to create a multi-tier system which makes names that would be inexpressible in Conway&Guys system, in the sense that they would be way too long to write out in full, quite expressible. It is in this sense that we may say that Bowers' system offers an advantage over that of Conway&Guy. Two important issues however hinder the system. Firstly, it is plagued by a certain irregularity and arbitrariness. The second issue stems from the first: that the system is only designed up to a certain point; it's a closed system, rather than an open one. At the end of the Bowers' article I speak about numbers that would require 10, a 100 or even a thousand tiers to express. But even if Bowers' system were extended in this manner it would still not name all the numbers. So the problem I want to resolve with my -illion series, is how to create an open ended system with a tier-type structure. This may at first seem impossible, but there is a fairly easy way to achieve this. I also want to correct the other difficultly of Bowers' system with my illion series: I want to construct the system in as logical and non-arbitrary way as possible.

So our goals for the system are as follows:

• • Create a tier-structructed -illion series

  • Which names all intermediates terms in the sequence

  • extends to all numbers

  • is logically constructed with a minimum of arbitrary elements

Let's first examine what an extended Bowers' type system would look like, and try to develop the basic theory of it's structure.

My Multi-Tier -illion System

Sometime around 2008, prior to the construction of my site I had worked out an extended multi-tier -illion system of my own, which I eventually intended to publish to my site. With this system I took the pattern I had come to recognize in Bowers' system and took it to its logical extreme, and even attempted to break that limit as well. The result was a very complicated system based on the tier concept expounded upon in the previous article. I will give a basic outline of the system for the sake of illustrating its problems and why a better method would be needed in order to achieve the goal of an open-ended tier system.

The system begins, much like Bowers', with the assumption that all the numbers up to a millillion are well established by Conway&Guys and similiar schemes, and should be taken as a common starting point.

In my original formulation I accepted the backward order of "components" so that the 23rd -illion would be:

trevigintillion

This reverse order continues to the hundreds so that the 123rd -illion would be:

treviginticentillion

To make it easier to explain how the first 999 illions were named I developed the idea of a root table, and realized that all the names were constructed simply as combinations of the root words. This is basically identical to the root table concept established by Conway&Guy in the book of numbers. For the 1st tier roots I modified Conway&Guys system slightly for simplicity. Very little finagling is necessary. Here is the Tier I root table:

Tier I Root Table

The table admittedly requires a little bit of interpretation, but not much. For convience let H(z) be the zth illion number. If z = 1 ~ 9 use the first option ones roots, if not use the second. The order of roots should always be:

[ones]-[tens]-[hundreds]-illion

If a component is not required, simply leave the position empty. As for the parenthesis in the above table, you do not include the letter in parenthesis if the component is followed by -illion, and if it is not then you must include it. These rules are very simple and its easy now to name any illion from 1~999:

83rd illion --> tr/tre-octogint(a)-illion --> treoctogintillion

234th illion --> quadr/quattuor-trigint(a)-ducent(i)-illion --> quattuortrigintaducentillion

109th illion --> non/novem-cent(i)-illion --> novemcentillion

To go further, I created a 2nd tier that used a 2nd root table based on the greek numbers (following Bowers pattern). How did I continue from there? I reasoned that if the first root table were latin, and the 2nd greek, I could keep adding tiers simply by adding more and more languages. The 3rd Tier used german numbers, the 4th used hebrew, the 5th sanskrit, the 6th welsh, the 7th urdu, the 8th used a weird variant of the SI prefixes, the 9th used some randomly created prefixes of my own devising, and the 10th used the number names I had devised in my 1099 unique names system. In this way I "surpassed" Bowers 4 Tier system with my own 10 Tier system. To continue I could simply add more tiers with more unique roots.

But there were 2 problems with this. Firstly, my 10-tier system was confusing and difficult to use. The languages used for the roots were chosen in an arbitrary way. The second problem was that no matter how many tiers I added the system would still be closed, only able to name some of the infinite number of powers of a thousand.

To remedy this I then devised an ad hoc way to go through combinations of letters to automatically develop new root tables to extend the tiers indefinitely. Not only did this result in extremely nonsensical and illogical names, but it relied on a method of having to know all previous root tables to generate the next. The result would be that just to know the name of the smallest 1000th tier number would require one to compute the roots for all the tiers from 1 to 999.

This would be the limit of Bower's approach. The result would be a messy system with the number of roots proportional to the number of tiers. Therefore to have an infinite number of tiers would require and infinite number of roots. Is it really necessary to have an infinite number of roots to name and infinite number of numbers?

No. We could simply say that the name of any whole number is the reading out of its digits. This system could name an infinite number of numbers, but would have only ten roots, namely: zero, one, two, three, four, five, six, seven, eight, and nine. In fact, in a somewhat more sophisticated way that's exactly how we name numbers in English, by reading out their digits along with an associated denomination. Of coarse we don't want to have to call a number like 10000000000 a name like "one zero zero zero zero zero zero zero zero zero zero". We want to have short names for certain roundish numbers. That's why the -illions were invented in the first place. So it may seem that we have reached an impasse and it's impossible to create a unlimited tier-system.

As we learned in the Henkle's article, Borgmann did not consider Henkle's proposal a satisfactory solution to the "counting problem". Henkle's proposal was further expanded and developed, and finally completed by Candelaria. Candelaria's system attempts to simplify the whole problem by trying to make roots recursive. For example, we might call the millionth illion a millillion, the billionth illion a billillion, the trillionth illion a trillillion,etc. At first this seems like a brilliantly simple solution. It further seems that we can continue this indefinitely, since we can call the millillionth illion a millillillion, the billillionth illion a billillillion, etc. The problem is that certain names will be ambiguous because they will appear more than once in the constructions. For example take a duodecillillion. Does that mean (2E33)-illion, or does it mean (E39)-illion? There is no good way to decide this because the same name would be constructed for both. In a sense the Candelaria system attempts to simplify matters by using the same roots for an infinite number of tiers. The result is that the bigger the numbers get the greater the ambiguity.

But if having an infinite number of unique tiers is untenable, and having repeat tiers is ambiguous, how can we have an infinite tier system? It turns out to be pretty simple. To help explain the concept allow me to take a detour to explain the fundamental theory behind it.

Tier Notation

To assist in the development of my original 10-tier system, I had developed a special notation for large numbers which later proved to be useful in the creation in my new system. I am calling it simply "Tier Notation" here, though I originally introduced it on my blog "Beyond G" as "Advanced Decimal Notation"

The idea is pretty simple, and once understood it makes the tier structure much easier to see.

Let's say we were going to create an -illion series for naming all the positive integer powers of a thousand. Naturally enough we could begin by using the names thousand, million, billion,...

Now rather than construct such a system, let there be a function such that (0) is the 0th member of the sequence, (1) is the 1st member, (2) is the 2nd member, so that:

(0) = thousand

(1) = million

(2) = billion

...

There is now no actual need to build such a sequence as we can simply use (n) to refer to the nth member of such a hypothetical sequence. Let "(n)" act as a substitute for the actual name of the nth member. So to name a number like:

999,999,999,999

We would simply say:

nine hundred ninety nine (2) nine hundred ninety nine (1) nine hundred ninety nine (0) nine hundred ninety nine

(n) acts as a separator between groups of digits, functioning the same way as commas.

Next we establish that:

n-illion = E(3n+3)

Thus:

0-illion = E3

1-illion = E6

2-illion = E9

3-illion = E12

etc.

I've set up things so that:

(n) = n-illion

Combining these two definitions allows us to make the tier structure readily apparent.

For example, the 1000th illion would simply be 1000-illion. However 1000 = (0), so we can also say the 1000th illion is (0)-illion. The 1,000,000th illion would be 1,000,000-illion, but since 1,000,000 = (1) we can also simply write (1)-illion.

For the 123,456,789th illion we can simply write:

123(1)456(0)789-illion

When a number is written to the right side of (n) let multiplication be implied. Anything written to the left of (n) it is added to the product. Here the tier structure becomes visible. The digits outside the parenthesis represent tier I roots, while the digits inside the parentheses are Tier II roots.

Sbiis Saibian's Tetronomical -illion Series

Now that we have some grounding in the problem and theory allow me to offer a solution. The system I'm about to describe is an open-ended system that will allow us to express certain tetrational class numbers compactly, similar to how the canonical -illions allow us to express certain exponential class numbers compactly ("Tetronomical" is just a portmanteau of "tetration" and "astronomical"). It is built from the same tier system I had built for my original -illion series, but unlike my original -illion series I will not need to use several different languages for all the roots. Instead all roots will be in latin, sensibly.

It begins simply enough by accepting the first 20 illions, and the centillion as canon. I will however make an important break with the common approach for extending through the 21st to the 99th -illion. In Conway&Guys original illion system, the order of the roots was reversed in imitation of the reversal that occurs through the 11th to 19th illions. This reversal for latin numbers from 11 to 19 is not unprecedented. It can be seen in many languages. Even in English we can see that a number like seventeen, is really just seven-ten, where the one's root comes before, not after, the ten's root. However the order almost universally reverses after 20 in most languages. I find that this backwards order, first used by Conway&Guy, and then adopted into other systems, is erroneous. Although it causes little problems from the 21st to 99th illion, it becomes problematic in a number of ways later down the road. Correcting the problem early on saves a lot of extra complication in the system being constructed. The catch however is that to correct the order problem we have to break with precedent and invent something new. This however is not too difficult. First let's revisit the latin numbers. From 1 to 10 we have unum, duo, tres, quattuor, quinque, sex, septem, octo, novem, and decem. For 11 through 20 we have undecim, duodecim, tredecim, quattuordecim, quindecim, sedecim, septendecim, octodecim, undeviginti, and viginti. These all follow pretty closely with the canonical illions with the exception of undevingti for 19 (this just means "one less than twenty"). The latin numbers continue as follows: viginti-unus, viginti-duo, viginti-tres, viginti-quatuor, viginti-quinque, viginti-sex, viginti-septem, viginti-octo, viginti-novem. It has been said that there is simply no good way to adapt the latin into a prefix for the illions. For example, if we were to literally just attach the latin number to illion we would follow vigintillion, with viginti-unusillion, viginti-duoillion, viginti-tresillion, viginti-quatuorillion, viginti-quinqueillion, viginti-sexillion, viginti-septemillion, viginti-octoillion, viginti-novemillion. These seem awkward. Then again if we applied the latin numbers 2 through 10 in place of the canonical illions, we would follow million, with duoillion, tresillion, quattuorillion, quinqueillion, sexillion, septemillion, octoillion, novemillion, and decemillion. It would seem natural then to use "viginti" as a prefix and then append it to our usual names for the canonical illions. Thus we would get viginti-million, viginti-billion, viginti-trillion, viginti-quadrillion, viginti-quintillion, viginti-sextillion, viginti-septillion, viginti-octillion, and viginti-nonillion. This is certainly better, though the first few sound odd, such as viginti-million, and viginti-billion. To make the names sound as latin based as possible I suggest the following continuation for the 21st through 29th illion. I will make a side to side comparison with Conway&Guy's, and Bower's system: