Infra Notation

Infra notation is a notation for large numbers made by Wikia user Nirvana Supermind..

The notation is currently composed of 1 parts, which is as follows:

• Basic Infra Notation (BIN)
• Linear Infra Notation (LIN)
• Basic Cascading Infra Notation (BCIN)

It shares many common but irregular features with the creator's preceding works Rampant Array Notation, Extensible Illion System, and Quick array notation, and hence we explains it first.

Feature

Unfortunately, this section is a target of the creator's removal.

We explain the specific features of notations by the creator and the corresponding articles.

1. Many of the articles have similar histroies:
   1. First, the creator creates an article in this wiki on his or her own notations by himself or herself, and insists statements such as well-definedness and analyses.
   2. Second, another user points out errors, ill-definedness, incorrectness of the creator's original statements.
   3. Third, the creator drastically removes descriptions mainly related to ill-definedness, including mathematical proofs of incorrectness of the creator's fake statement and alternative definitions which solve issues in the original definition.
   4. Finally, the unconstructive removements are reverted, and sources of the creator's manipulations are added to the articles.
2. Whenever the creator makes a new notation, they say "it is composed of <number> parts", even if they do not intend to expand it.
3. The creator insists statements on well-definedness, analyses, and intended values by just asserting them or writing something like "this most likely reaches <ordinal>", but usually the original statements are wrong. Indeed, none of them was well-defined when the creator created the corresponding article in this wiki. When another user points out the incorrectness, then the creator dishonestly removes the description including mathematical proofs of the incorrectness, as if they were correct. Therefore we should not believe the creator's "most likely" unless he or she gave a proof or a peer-reviewed source.

See also Rampant Array Notation, Extensible Illion System, and Quick array notation for the sources of the feature.

Unfortunately, this notation is not a counterexample. Since these features are quite special in googology, we deeply explain them together with full sources.

Basic notation

Basic Infra Notation (BIN) is the 1st part of Infra Notation. It’s the simplest and weakest one. Unfortunately, it was ill-defined, as we will explain later.

Original version

Unfortunately, the most part of this section is a target of the creator's removal during the creator's renaming of this section. Moreover, the creator insisted that this section was not a target of the removal during the removal of this section. To be more precise, the creator is trying to rename this section, and simultaneously removing several contents of this section.

Definition

A valid expression in this notation is of the form I<>, I<a>, or I<a,b> for non-negative integers a and b. The rules for a valid expression are:

1. I<> = 0
2. I<a> = 10^a
3. I<#,0> = I<#>
4. I<a,b> = I<I<...<I<a,b-1>,b-1>,...>,b-1> (b>0) for a times

Where # is a part of said array (a string of entries and commas, it can also be empty). If there are two or more distinct rules to apply to a single expression, the uppermost-numbered rule which is applicable and whose result is a valid expression will be applied.

Issue

Although the phrase "for a times" is ambiguous or is a typo of some precise description, it seems to mean the depth of the nest at least when a is positive. Since the creator tried to remove the sentence above explaining the ambiguity of the phrase "for a times", he or she strongly believes that there is no ambiguity. The creator insisted that this notation most likely reaches \(f_{\omega}(n)\) in the Fast-growing hierarchy.

As we have explained, the creator always insists something like "this notation is well-defined" or "this notation most likely reaches <ordinal>", but those statements are not necessarily true. For example, I<0,1> is ill-defined because there is no rule applied to it. The first three rules are not applicable to it. The fourth rule is applicable to it, but the result is not defined, as the description "for 0 times" itself is ambiguous. According to the creator, the result of the application of rule 4 to I<0,1> is I<>, but they skip over how it is derived. After applying rule 4, it becomes I<I<...<I<0,0>,0>,...>,0> for 0 times. This does not make sense. The creator tends to insists that any error pointed by others can be regarded as a typo, and hence does not contribute to the ill-definedness. If one stands on the creator's viewpoint that any error is a typo which does not contribute to the ill-definedness, then it might be regarded as a well-defined notation whose computation rule is uniquely applicable to any valid expression. Anyway, there is no reasonable explanation why we should expand I<0,1> as the intended expression I<>.

Example

I<3,1>

= I<I<...<I<3,0>,0>,...>,0> for 3 times

= I<I<I<3,0>,0>,0>

= I<I<I<3>>>

= 10¹⁰¹⁰⁰⁰

I<0,1> = ill-defined (According to the creator, it expands as I<>.)

Alternative definition

Unfortunately, this section was a target of the creator's removal. However, the creator insists that this section was not a target of the removal, even though we have the sources. According to the creator, he or she kept this section, but we can easily show that he or she is cheating simply by checking the four sources. After another user pointed out this fact, then the creator changed the statement; the creator actually removed this section so many times, but created a condensed section instead. Namely, the creator accepted the removement. Later, the creator insisted that he or she was going to rename and move the section, but just removed it because he or she had no times.

Definition

It is quite elementary to fix the issue. For example, we define a non-negative integer I<@> for any array @ of non-negative integers in the following recursive way:

1. If @ is the empty string, then I<@> = 0.
2. If @ = "a" for a non-negative integer a, then I<@> = 10^a.
3. If @ = "#,0" for a non-empty array # of non-negative integers, then I<@> = I<#>.
4. If @ = "#,a,b" for an array # of non-negative integers, non-negative integer a, and a positive integer b, then I<@> = I^a<#,a,b-1>, where Iⁿ<#,a,b-1> is the non-negative integer defined for any non-negative integer n in the following recursive way:
   1. If n = 0, then Iⁿ<#,a,b-1> = a.
   2. If n ≠ 0, then Iⁿ<#,a,b-1> = I<#,I^n-1<#,a,b-1>,b-1>.

For example, we have I<0,1> = I⁰<0,0> = 0. Fortunately, this result coincides with the creator's intension I<0,1> = I<> = 0. Therefore the restriction of this alternative definition to the subset of the domain consisting of arrays of length at most 2 is perhaps equivalent to the original definition fixed in some intended way.

Example

I<0,1> = I⁰<0,0> = 0.

Second definition

Unfortunately, the most part of this section is a target of the creator's removal during the creator's renaming of this section. To be more precise, the creator is trying to rename this section, and simultaneously removing several contents of this section.

After the ill-definedness was pointed out, the creator first could not understand the issue, as he or she dishonestly removed the description and the alternative definition above twice, by insisting that the description was wrong. Later, the creator understood the ill-definedness. Although the creator somewhy repeated to remove the alternative definition or rename the section for the alternative definition he or she added a second definition. The main change from the original definition is that the domain is restricted to the subset of arrays of length at most 2 whose entries are positive integers instead of non-negative integers.

Definition

A valid expression in this notation is of the form I<>, I<a>, or I<a,b> for positive integers a and b. The rules for a valid expression are:

1. I<> = 0
2. I<a> = 10^a
3. I<#,1> = I<#>
4. I<a,b> = I<I<...<I<a,b-1>,b-1>,...>,b-1> (b>0) for a times

Where # is a part of said array (a string of entries and commas, it can also be empty). If there are two or more distinct rules to apply to a single expression, the uppermost-numbered rule which is applicable and whose result is a valid expression will be applied. Similar to the original definition, the phrase "for a times" is ambiguous or is a typo of some precise description, but it seems to mean the depth of the nest. As we explained above, the creator perhaps considers that there cannot be any ambiguity here, although the ill-definedness of the original definition is due to the ambiguity here.

Since there is no different rule other than the third rule, it is identical to a subsystem of the notation given by the alternative definition except for shifting the second imput (and other higher imputs) by 1, if the ambiguous phrase "for a times" actually means what we have explained above.

According to the creator, the description "for a times" was stolen from Username5243's notation. The creator insists that Username5243 is known for making fast-growing welldefined notations, and hence he or she seems to believe that there should be no ambiguity if he or she follows a similar way to define a notation.

Example

One significant point is that the result of I<3,1> has changed, as the creator replaced the third rule. However, according to the creator, the expansion of I<3,1> has not changed. Therefore we explain both intended values and actual values.

Intended Value

I<3,1>

= I<I<...<I<3,0>,0>,...>,0> for 3 times

= I<I<I<3,0>,0>,0> (This is ill-defined because it is an invalid expression in the second definition, but the creator continued the computation.)

I<3,2>

= I<I<…<I<3,1>,1>,…>,1> for 3 times

= I<I<I<3,1>,1,1> (This is ill-defined because it is an invalid expression, but the creator continued the computation.)

Actual Value

• I<3,1> = I<3> = 10³ = 1000
• I<3,2> = I<I<I<3,1>,1>,1> = I<I<1000,1>,1> = I<I<1000>,1> = I<10¹⁰⁰⁰,1> = I<10¹⁰⁰⁰> = 10¹⁰¹⁰⁰⁰

Therefore the explanation by the creator is still inconsistent.

See also

• Rampant Array Notation
• Extensible Illion System
• Quick array notation