Extensible Illion System

Not to be confused with Extensible-E System.

Extensible Illion System
state	ill-defined
Based On	-illions

Extensible Illion System is a notation by Nirvana Supermind (for generating large -illions). It is divided into extensions, and there is currently just one:

1. Primitive Illion System

Although the creator insists that this is well-defined, this is ill-defined, as is explained later.

Primitive Illion System

One of the biggest feature of this notation is that the creator is insisting the well-definedness even after errors are pointed out. Once the ill-definedness was pointed out in this article, then the creator removed the descriptions such as the original definition, the retrieval dates, issues, and the ill-definedness saying lies such as ""I remove NO INFORMATION except for the ill defined part and "intended to be....", not a SINGLE BIT OF IT AT ALL, I am just adding new information and removing the ill-defined part. That's all. NOTHING. ELSE."". The same incident occurred in the article of Rampant Array Notation, which is another ill-defined system of the creator. Since this is an irregular feature in googology, this article is mainly devoted to the history of the notation.

The primitive notation takes a base and any amount of arguments, which are non-negative integers. The original rules for it are:

1. 0[b] = 10^3b+3
2. a[b] = a-1[b,b,b,b…] with b “b”s for a>0
3. a[b,c] = a[a[b,c-1]/1000]
4. a[#,0] = a[#]
5. a[#,b,c] = a[#,a[#,b,c-1]] for c>0

Here, # is a portion of the array, which can be empty.

This notation was intended to reach w^2 in the fast-growing hierarchy, but was ill-defined because of many errors:

1. There is no rule applicable to 0[] and 1[].
2. There are two distinct ways to solve 1[0].
   1. If you apply the rule 2, then the result will be 0[], which is ill-defined by the reason above.
   2. If you apply the rule 4, then the result will be 1[], which is ill-defined by the reason above.
3. There are two distinct ways to solve 1[0,0].
   1. If you apply the rule 3, then the result will be 1[1[0,-1]/1000], which is ill-defined because -1 is negative.
   2. If you apply the rule 4, then the result will be 1[0], which is ill-defined by the reason above.

Later, the creator updated the definition by adding the case for the empty array:

1. 0[b] = 10^3b+3
2. a[] = 1000
3. a[b] = a-1[b,b,b,b…] with b “b”s for a>0
4. a[b,c] = a[a[b,c-1]/1000]
5. a[#,0] = a[#]
6. a[#,b,c] = a[#,a[#,b,c-1]] for c>0

Here, # is a portion of the array, which can be empty. If there are two or more distinct rules to apply to a single expression, the upper rule will be applied.

Indeed, it is still ill-defined because of the same issues for 1[0,0] (the invalidity of 1[0,-1]), while the creator still insists that it is well-defined. In this second definition, 1[0,0] should be solved by the forth rule because the rule forces us to apply the upper most rule applicable to it. The priority order of rules is actually what the second definition explains, but the creator is trying to hide this fact by removing or changing the description with saying that the creator removed or changed nothing as if the priority order were corrected from the beginning.

The current definition is the same as the second definition except for the priority order of rules. As the issue on 1[0,0] has been pointed out, the creator tried to avoid the issue by clarifying "If there are two or more distinct rules to apply to a single expression, the upper rule will be applied if it is well-defined, otherwise the lower rule." However, refering to the well-definedness itself in order to make a notation well-defined just causes a circular logic. As a conclusion, the notation is still ill-defined, although the creator insists that it is well-defined.

Although the creator failed to make the notation well-defined and is just insisting that it is well-defined, there are several simple and elementary solutions by setting complete case classification without overlapping. For example, one natural inofficial alternative definition of a[@] for a non-negative integer a and a (possibly empty) array @ of non-negative integers can be given in the following recursive way:

1. If a = 0 and @ = "b" for a non-negative integer b, then a[@] = 10^3b+3.
2. If @ is empty, then a[@] = 1000
3. If a > 0 and @ = "b" for a non-negative integer b, then a[@] = a-1[b,b,b,b…] with b b's.
4. If @ = "b,c" for a non-negative integer b and a positive integer c, then a[@] = a[a[b,c-1] 10^-3].
5. If @ = "#,0" for a non-empty array # of non-negative integers, then a[@] = a[#].
6. If @ = "#,b,c" for a non-empty array # of non-negative integers, a non-negative integer b, and a positive integer c, then a[@] = a[#,a[#,b,c-1]].

Then the issue on 1[0,0] does not occur, because the forth rule is not applicable to it and the fifth rule is applicable to it.

Example

0[4,1,1] = 0[4,0[4,1]]

0[4,1] = 0[0[4,0]/1000]

0[4,0] = 0[4] = 10¹⁵

0[4,1] = 0[10¹⁵/1000] = 0[10¹²].

0[4,1,1] = 0[4,10¹²] is intended to be 1010^(3*10^12+3)3*10^12+3, but the result is doubtful. The result should be a power of 10, but the creator insists that 1010^(3*10^12+3)3*10^12+3, which is 3 module 10, is the correct value.